自学教程：C++ CVProcessError函数代码示例

int CVSpilsSetJacTimesVecFnB(void *cvadj_mem, CVSpilsJacTimesVecFnB jtimesB,                             void *jac_dataB){  CVadjMem ca_mem;  CVSpilsMemB cvspilsB_mem;   CVodeMem cvB_mem;  int flag;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CVSPILS_ADJMEM_NULL, "CVSPILS", "CVSpilsSetJacTimesVecFnB", MSGS_CAMEM_NULL);    return(CVSPILS_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  if (lmemB == NULL) {    CVProcessError(cvB_mem, CVSPILS_LMEMB_NULL, "CVSPILS", "CVSpilsSetJacTimesVecFnB", MSGS_LMEMB_NULL);    return(CVSPILS_LMEMB_NULL);  }  cvspilsB_mem = (CVSpilsMemB) lmemB;  jtimes_B   = jtimesB;  jac_data_B = jac_dataB;  flag = CVSpilsSetJacTimesVecFn(cvB_mem, CVAspilsJacTimesVec, cvadj_mem);  return(flag);}

int CVBBDPrecGetNumGfnEvals(void *cvode_mem, long int *ngevalsBBDP){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  CVBBDPrecData pdata;  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecGetNumGfnEvals", MSGBBD_MEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (cv_mem->cv_lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecGetNumGfnEvals", MSGBBD_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;  if (cvspils_mem->s_P_data == NULL) {    CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBBDPRE", "CVBBDPrecGetNumGfnEvals", MSGBBD_PMEM_NULL);    return(CVSPILS_PMEM_NULL);  }   pdata = (CVBBDPrecData) cvspils_mem->s_P_data;  *ngevalsBBDP = pdata->nge;  return(CVSPILS_SUCCESS);}

int CVSpilsSetPreconditionerB(void *cvadj_mem, CVSpilsPrecSetupFnB psetB,                              CVSpilsPrecSolveFnB psolveB, void *P_dataB){  CVadjMem ca_mem;  CVSpilsMemB cvspilsB_mem;   CVodeMem cvB_mem;  int flag;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CVSPILS_ADJMEM_NULL, "CVSPILS", "CVSpilsSetPreconditionerB", MSGS_CAMEM_NULL);    return(CVSPILS_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  if (lmemB == NULL) {    CVProcessError(cvB_mem, CVSPILS_LMEMB_NULL, "CVSPILS", "CVSpilsSetPreconditonerB", MSGS_LMEMB_NULL);    return(CVSPILS_LMEMB_NULL);  }  cvspilsB_mem = (CVSpilsMemB) lmemB;  pset_B   = psetB;  psolve_B = psolveB;  P_data_B = P_dataB;  flag = CVSpilsSetPreconditioner(cvB_mem, CVAspilsPrecSetup, CVAspilsPrecSolve, cvadj_mem);  return(flag);}

int CVSpilsSetDelt(void *cvode_mem, realtype delt){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetDelt", MSGS_CVMEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetDelt", MSGS_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) lmem;  /* Check for legal delt */  if(delt < ZERO) {    CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetDelt", MSGS_BAD_DELT);    return(CVSPILS_ILL_INPUT);  }  cvspils_mem->s_delt = (delt == ZERO) ? CVSPILS_DELT : delt;  return(CVSPILS_SUCCESS);}

int CVSpilsSetPreconditioner(void *cvode_mem, CVSpilsPrecSetupFn pset,                              CVSpilsPrecSolveFn psolve, void *P_data){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetPreconditioner", MSGS_CVMEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetPreconditioner", MSGS_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) lmem;  cvspils_mem->s_pset = pset;  cvspils_mem->s_psolve = psolve;  if (psolve != NULL) cvspils_mem->s_P_data = P_data;  return(CVSPILS_SUCCESS);}

int CVSpilsSetGSType(void *cvode_mem, int gstype){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetGSType", MSGS_CVMEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetGSType", MSGS_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) lmem;  if (ils_type != SPILS_SPGMR) {    CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetGSType", MSGS_BAD_LSTYPE);    return(CVSPILS_ILL_INPUT);  }  /* Check for legal gstype */  if ((gstype != MODIFIED_GS) && (gstype != CLASSICAL_GS)) {    CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetGSType", MSGS_BAD_GSTYPE);    return(CVSPILS_ILL_INPUT);  }  cvspils_mem->s_gstype = gstype;  return(CVSPILS_SUCCESS);}

int CVSpilsSetMaxl(void *cvode_mem, int maxl){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  int mxl;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetMaxl", MSGS_CVMEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(NULL, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetMaxl", MSGS_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) lmem;  if (ils_type == SPILS_SPGMR) {    CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetMaxl", MSGS_BAD_LSTYPE);    return(CVSPILS_ILL_INPUT);  }  mxl = (maxl <= 0) ? CVSPILS_MAXL : maxl;  cvspils_mem->s_maxl = mxl;  /*  spbcg_mem->l_max  = mxl; */  return(CVSPILS_SUCCESS);}

int CVBandPrecGetNumRhsEvals(void *cvode_mem, long int *nfevalsBP){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  CVBandPrecData pdata;  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBANDPRE", "CVBandPrecGetNumRhsEvals", MSGBP_MEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (cv_mem->cv_lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBANDPRE", "CVBandPrecGetNumRhsEvals", MSGBP_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;  if (cvspils_mem->s_P_data == NULL) {    CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBANDPRE", "CVBandPrecGetNumRhsEvals", MSGBP_PMEM_NULL);    return(CVSPILS_PMEM_NULL);  }   pdata = (CVBandPrecData) cvspils_mem->s_P_data;  *nfevalsBP = pdata->nfeBP;  return(CVSPILS_SUCCESS);}

int CVadjGetDataPointPolynomial(void *cvadj_mem, long int which,                                 realtype *t, int *order, N_Vector y){  CVadjMem ca_mem;  DtpntMem *dt_mem;  PolynomialDataMem content;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVadjGetDataPointPolynomial", MSGAM_NULL_CAMEM);    return(CV_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  dt_mem = ca_mem->dt_mem;  if (interpType != CV_POLYNOMIAL) {    CVProcessError(NULL, CV_ILL_INPUT, "CVODEA", "CVadjGetDataPointPolynomial", MSGAM_WRONG_INTERP);    return(CV_ILL_INPUT);  }  *t = dt_mem[which]->t;  content = (PolynomialDataMem) (dt_mem[which]->content);  if (y != NULL)    N_VScale(ONE, content->y, y);  *order = content->order;  return(CV_SUCCESS);}

int CVadjGetDataPointHermite(void *cvadj_mem, long int which,                              realtype *t, N_Vector y, N_Vector yd){  CVadjMem ca_mem;  DtpntMem *dt_mem;  HermiteDataMem content;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVadjGetDataPointHermite", MSGAM_NULL_CAMEM);    return(CV_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  dt_mem = ca_mem->dt_mem;  if (interpType != CV_HERMITE) {    CVProcessError(NULL, CV_ILL_INPUT, "CVODEA", "CVadjGetDataPointHermite", MSGAM_WRONG_INTERP);    return(CV_ILL_INPUT);  }  *t = dt_mem[which]->t;  content = (HermiteDataMem) (dt_mem[which]->content);  if (y != NULL)    N_VScale(ONE, content->y, y);  if (yd != NULL)    N_VScale(ONE, content->yd, yd);  return(CV_SUCCESS);}

int CVBBDPrecGetWorkSpace(void *cvode_mem, long int *lenrwBBDP, long int *leniwBBDP){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  CVBBDPrecData pdata;  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecGetWorkSpace", MSGBBD_MEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (cv_mem->cv_lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecGetWorkSpace", MSGBBD_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;  if (cvspils_mem->s_P_data == NULL) {    CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBBDPRE", "CVBBDPrecGetWorkSpace", MSGBBD_PMEM_NULL);    return(CVSPILS_PMEM_NULL);  }   pdata = (CVBBDPrecData) cvspils_mem->s_P_data;  *lenrwBBDP = pdata->rpwsize;  *leniwBBDP = pdata->ipwsize;  return(CVSPILS_SUCCESS);}

int CVSpilsSetPrecType(void *cvode_mem, int pretype){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetPrecType", MSGS_CVMEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetPrecType", MSGS_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) lmem;  /* Check for legal pretype */   if ((pretype != PREC_NONE) && (pretype != PREC_LEFT) &&      (pretype != PREC_RIGHT) && (pretype != PREC_BOTH)) {    CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetPrecType", MSGS_BAD_PRETYPE);    return(CVSPILS_ILL_INPUT);  }  cvspils_mem->s_pretype = pretype;  return(CVSPILS_SUCCESS);}

int CVBandSetJacFnB(void *cvadj_mem, CVBandJacFnB bjacB, void *jac_dataB){  CVadjMem ca_mem;  CVBandMemB cvbandB_mem;  CVodeMem cvB_mem;  int flag;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CVBAND_ADJMEM_NULL, "CVBAND", "CVBandSetJacFnB", MSGB_CAMEM_NULL);    return(CVBAND_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  if (lmemB == NULL) {    CVProcessError(cvB_mem, CVBAND_LMEMB_NULL, "CVBAND", "CVBandSetJacFnB", MSGB_LMEMB_NULL);    return(CVBAND_LMEMB_NULL);  }  cvbandB_mem = (CVBandMemB) lmemB;  bjac_B     = bjacB;  jac_data_B = jac_dataB;  flag = CVBandSetJacFn(cvB_mem, CVAbandJac, cvadj_mem);  return(flag);}

/* * CVDlsGetWorkSpace returns the length of workspace allocated for the * CVDLS linear solver. */int CVDlsGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int *leniwLS){  CVodeMem cv_mem;  CVDlsMem cvdls_mem;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVDLS_MEM_NULL, "CVDLS", "CVDlsGetWorkSpace", MSGD_CVMEM_NULL);    return(CVDLS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(cv_mem, CVDLS_LMEM_NULL, "CVDLS", "CVDlsGetWorkSpace", MSGD_LMEM_NULL);    return(CVDLS_LMEM_NULL);  }  cvdls_mem = (CVDlsMem) lmem;  if (mtype == SUNDIALS_DENSE) {    *lenrwLS = 2*n*n;    *leniwLS = n;  } else if (mtype == SUNDIALS_BAND) {    *lenrwLS = n*(smu + mu + 2*ml + 2);    *leniwLS = n;  }  return(CVDLS_SUCCESS);}

int CVodeSetMaxStep(void *cvode_mem, realtype hmax){  realtype hmax_inv;  CVodeMem cv_mem;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetMaxStep", MSGCV_NO_MEM);    return (CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (hmax < 0) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxStep", MSGCV_NEG_HMAX);    return(CV_ILL_INPUT);  }  /* Passing 0 sets hmax = infinity */  if (hmax == ZERO) {    cv_mem->cv_hmax_inv = HMAX_INV_DEFAULT;    return(CV_SUCCESS);  }  hmax_inv = ONE/hmax;  if (hmax_inv * cv_mem->cv_hmin > ONE) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxStep", MSGCV_BAD_HMIN_HMAX);    return(CV_ILL_INPUT);  }  cv_mem->cv_hmax_inv = hmax_inv;  return(CV_SUCCESS);}

int CVodeSetStopTime(void *cvode_mem, realtype tstop){  CVodeMem cv_mem;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetStopTime", MSGCV_NO_MEM);    return (CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  /* If CVode was called at least once, test if tstop is legal   * (i.e. if it was not already passed).   * If CVodeSetStopTime is called before the first call to CVode,   * tstop will be checked in CVode. */  if (cv_mem->cv_nst > 0) {    if ( (tstop - cv_mem->cv_tn) * cv_mem->cv_h < ZERO ) {      CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetStopTime", MSGCV_BAD_TSTOP, cv_mem->cv_tn);      return(CV_ILL_INPUT);    }  }  cv_mem->cv_tstop = tstop;  cv_mem->cv_tstopset = TRUE;  return(CV_SUCCESS);}

/* * CVDlsSetDenseJacFn specifies the dense Jacobian function. */int CVDlsSetDenseJacFn(void *cvode_mem, CVDlsDenseJacFn jac){  CVodeMem cv_mem;  CVDlsMem cvdls_mem;  /* Return immediately if cvode_mem is NULL */  if (cvode_mem == NULL) {    CVProcessError(NULL, CVDLS_MEM_NULL, "CVDLS", "CVDlsSetDenseJacFn", MSGD_CVMEM_NULL);    return(CVDLS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (lmem == NULL) {    CVProcessError(cv_mem, CVDLS_LMEM_NULL, "CVDLS", "CVDlsSetDenseJacFn", MSGD_LMEM_NULL);    return(CVDLS_LMEM_NULL);  }  cvdls_mem = (CVDlsMem) lmem;  if (jac != NULL) {    jacDQ = FALSE;    djac = jac;  } else {    jacDQ = TRUE;  }  return(CVDLS_SUCCESS);}

int CVodeSetMinStep(void *cvode_mem, realtype hmin){  CVodeMem cv_mem;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetMinStep", MSGCV_NO_MEM);    return(CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (hmin<0) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMinStep", MSGCV_NEG_HMIN);    return(CV_ILL_INPUT);  }  /* Passing 0 sets hmin = zero */  if (hmin == ZERO) {    cv_mem->cv_hmin = HMIN_DEFAULT;    return(CV_SUCCESS);  }  if (hmin * cv_mem->cv_hmax_inv > ONE) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMinStep", MSGCV_BAD_HMIN_HMAX);    return(CV_ILL_INPUT);  }  cv_mem->cv_hmin = hmin;  return(CV_SUCCESS);}

int CVodeSetMaxOrd(void *cvode_mem, int maxord){  CVodeMem cv_mem;  int qmax_alloc;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetMaxOrd", MSGCV_NO_MEM);    return(CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if (maxord <= 0) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxOrd", MSGCV_NEG_MAXORD);    return(CV_ILL_INPUT);  }    /* Cannot increase maximum order beyond the value that     was used when allocating memory */  qmax_alloc = cv_mem->cv_qmax_alloc;  if (maxord > qmax_alloc) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxOrd", MSGCV_BAD_MAXORD);    return(CV_ILL_INPUT);  }  cv_mem->cv_qmax = maxord;  return(CV_SUCCESS);}

static int CVDiagSetup(CVodeMem cv_mem, int convfail, N_Vector ypred,                       N_Vector fpred, booleantype *jcurPtr, N_Vector vtemp1,                       N_Vector vtemp2, N_Vector vtemp3){  realtype r;  N_Vector ftemp, y;  booleantype invOK;  CVDiagMem cvdiag_mem;  int retval;  cvdiag_mem = (CVDiagMem) lmem;  /* Rename work vectors for use as temporary values of y and f */  ftemp = vtemp1;  y     = vtemp2;  /* Form y with perturbation = FRACT*(func. iter. correction) */  r = FRACT * rl1;  N_VLinearSum(h, fpred, -ONE, zn[1], ftemp);  N_VLinearSum(r, ftemp, ONE, ypred, y);  /* Evaluate f at perturbed y */  retval = f(tn, y, M, f_data);  nfeDI++;  if (retval < 0) {    CVProcessError(cv_mem, CVDIAG_RHSFUNC_UNRECVR, "CVDIAG", "CVDiagSetup", MSGDG_RHSFUNC_FAILED);    last_flag = CVDIAG_RHSFUNC_UNRECVR;    return(-1);  }  if (retval > 0) {    last_flag = CVDIAG_RHSFUNC_RECVR;    return(1);  }  /* Construct M = I - gamma*J with J = diag(deltaf_i/deltay_i) */  N_VLinearSum(ONE, M, -ONE, fpred, M);  N_VLinearSum(FRACT, ftemp, -h, M, M);  N_VProd(ftemp, ewt, y);  /* Protect against deltay_i being at roundoff level */  N_VCompare(uround, y, bit);  N_VAddConst(bit, -ONE, bitcomp);  N_VProd(ftemp, bit, y);  N_VLinearSum(FRACT, y, -ONE, bitcomp, y);  N_VDiv(M, y, M);  N_VProd(M, bit, M);  N_VLinearSum(ONE, M, -ONE, bitcomp, M);  /* Invert M with test for zero components */  invOK = N_VInvTest(M, M);  if (!invOK) {    last_flag = CVDIAG_INV_FAIL;    return(1);  }  /* Set jcur = TRUE, save gamma in gammasv, and return */  *jcurPtr = TRUE;  gammasv = gamma;  last_flag = CVDIAG_SUCCESS;  return(0);}

int CVodeGetIntegratorStats(void *cvode_mem, long int *nsteps, long int *nfevals,                             long int *nlinsetups, long int *netfails, int *qlast,                             int *qcur, realtype *hinused, realtype *hlast,                             realtype *hcur, realtype *tcur){  CVodeMem cv_mem;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeGetIntegratorStats", MSGCV_NO_MEM);    return(CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  *nsteps = nst;  *nfevals = nfe;  *nlinsetups = nsetups;  *netfails = netf;  *qlast = qu;  *qcur = next_q;  *hinused = h0u;  *hlast = hu;  *hcur = next_h;  *tcur = tn;  return(CV_SUCCESS);}

int CVAspilsJacTimesVec(N_Vector vB, N_Vector JvB, realtype t,                         N_Vector yB, N_Vector fyB,                         void *cvadj_mem, N_Vector tmpB){  CVadjMem ca_mem;  CVodeMem cvB_mem;  CVSpilsMemB cvspilsB_mem;  int retval, flag;  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  cvspilsB_mem = (CVSpilsMemB) lmemB;  /* Forward solution from interpolation */  flag = getY(ca_mem, t, ytmp);  if (flag != CV_SUCCESS) {    CVProcessError(cvB_mem, -1, "CVSPILS", "CVAspilsJacTimesVec", MSGS_BAD_T);    return(-1);  }   /* Call user's adjoint jtimesB routine */  retval = jtimes_B(vB, JvB, t, ytmp, yB, fyB, jac_data_B, tmpB);  return(retval);}

static int CVAbandJac(long int nB, long int mupperB,                       long int mlowerB, BandMat JB, realtype t,                       N_Vector yB, N_Vector fyB, void *cvadj_mem,                       N_Vector tmp1B, N_Vector tmp2B, N_Vector tmp3B){  CVadjMem ca_mem;  CVodeMem cvB_mem;  CVBandMemB cvbandB_mem;  int retval, flag;  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  cvbandB_mem = (CVBandMemB) lmemB;  /* Forward solution from interpolation */  flag = getY(ca_mem, t, ytmp);  if (flag != CV_SUCCESS) {    CVProcessError(cvB_mem, -1, "CVBAND", "CVAbandJac", MSGB_BAD_T);    return(-1);  }  /* Call user's adjoint band bjacB routine */  retval = bjac_B(nB, mupperB, mlowerB, JB, t, ytmp, yB, fyB, jac_data_B,                  tmp1B, tmp2B, tmp3B);  return(retval);}

int CVAspilsPrecSetup(realtype t, N_Vector yB,                       N_Vector fyB, booleantype jokB,                       booleantype *jcurPtrB, realtype gammaB,                      void *cvadj_mem,                      N_Vector tmp1B, N_Vector tmp2B, N_Vector tmp3B){  CVadjMem ca_mem;  CVodeMem cvB_mem;  CVSpilsMemB cvspilsB_mem;  int retval, flag;  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  cvspilsB_mem = (CVSpilsMemB) lmemB;  /* Forward solution from interpolation */  flag = getY(ca_mem, t, ytmp);  if (flag != CV_SUCCESS) {    CVProcessError(cvB_mem, -1, "CVSPILS", "CVAspilsPrecSetup", MSGS_BAD_T);    return(-1);  }   /* Call user's adjoint precondB routine */  retval = pset_B(t, ytmp, yB, fyB, jokB, jcurPtrB, gammaB,                  P_data_B, tmp1B, tmp2B, tmp3B);  return(retval);}

int CVadjGetCheckPointsInfo(void *cvadj_mem, CVadjCheckPointRec *ckpnt){  CVadjMem ca_mem;  CkpntMem ck_mem;  int i;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVadjGetCheckPointsInfo", MSGAM_NULL_CAMEM);    return(CV_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  ck_mem = ca_mem->ck_mem;  i = 0;  while (ck_mem != NULL) {    ckpnt[i].my_addr = (void *) ck_mem;    ckpnt[i].next_addr = (void *) next_;    ckpnt[i].t0 = t0_;    ckpnt[i].t1 = t1_;    ckpnt[i].nstep = nst_;    ckpnt[i].order = q_;    ckpnt[i].step = h_;    ck_mem = next_;    i++;  }  return(CV_SUCCESS);}

int CVAspilsPrecSolve(realtype t, N_Vector yB, N_Vector fyB,                      N_Vector rB, N_Vector zB,                      realtype gammaB, realtype deltaB,                      int lrB, void *cvadj_mem, N_Vector tmpB){  CVadjMem ca_mem;  CVodeMem cvB_mem;  CVSpilsMemB cvspilsB_mem;  int retval, flag;  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;  cvspilsB_mem = (CVSpilsMemB) lmemB;  /* Forward solution from interpolation */  flag = getY(ca_mem, t, ytmp);  if (flag != CV_SUCCESS) {    CVProcessError(cvB_mem, -1, "CVSPILS", "CVAspilsPrecSolve", MSGS_BAD_T);    return(-1);  }  /* Call user's adjoint psolveB routine */  retval = psolve_B(t, ytmp, yB, fyB, rB, zB, gammaB, deltaB,                     lrB, P_data_B, tmpB);  return(retval);}

int CVSpbcgB(void *cvadj_mem, int pretypeB, int maxlB){  CVadjMem ca_mem;  CVSpilsMemB cvspilsB_mem;  CVodeMem cvB_mem;  int flag;  if (cvadj_mem == NULL) {    CVProcessError(NULL, CVSPILS_ADJMEM_NULL, "CVSPBCG", "CVSpbcgB", MSGS_CAMEM_NULL);    return(CVSPILS_ADJMEM_NULL);  }  ca_mem = (CVadjMem) cvadj_mem;  cvB_mem = ca_mem->cvb_mem;    /* Get memory for CVSpilsMemRecB */  cvspilsB_mem = NULL;  cvspilsB_mem = (CVSpilsMemB) malloc(sizeof(CVSpilsMemRecB));  if (cvspilsB_mem == NULL) {    CVProcessError(cvB_mem, CVSPILS_MEM_FAIL, "CVSPBCG", "CVSpbcgB", MSGS_MEM_FAIL);    return(CVSPILS_MEM_FAIL);  }  pset_B = NULL;  psolve_B = NULL;  jtimes_B = NULL;  P_data_B = NULL;  jac_data_B = NULL;  /* attach lmemB and lfree */  lmemB = cvspilsB_mem;  lfreeB = CVSpbcgFreeB;  flag = CVSpbcg(cvB_mem, pretypeB, maxlB);  if (flag != CVSPILS_SUCCESS) {    free(cvspilsB_mem);    cvspilsB_mem = NULL;  }  return(flag);}

int CVBBDPrecReInit(void *cvode_mem,                     int mudq, int mldq,                     realtype dqrely){  CVodeMem cv_mem;  CVSpilsMem cvspils_mem;  CVBBDPrecData pdata;  int Nlocal;  if (cvode_mem == NULL) {    CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecReInit", MSGBBD_MEM_NULL);    return(CVSPILS_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  /* Test if one of the SPILS linear solvers has been attached */  if (cv_mem->cv_lmem == NULL) {    CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecReInit", MSGBBD_LMEM_NULL);    return(CVSPILS_LMEM_NULL);  }  cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;  /* Test if the preconditioner data is non-NULL */  if (cvspils_mem->s_P_data == NULL) {    CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBBDPRE", "CVBBDPrecReInit", MSGBBD_PMEM_NULL);    return(CVSPILS_PMEM_NULL);  }   pdata = (CVBBDPrecData) cvspils_mem->s_P_data;  /* Load half-bandwidths */  Nlocal = pdata->n_local;  pdata->mudq = MIN(Nlocal-1, MAX(0,mudq));  pdata->mldq = MIN(Nlocal-1, MAX(0,mldq));  /* Set pdata->dqrely based on input dqrely (0 implies default). */  pdata->dqrely = (dqrely > ZERO) ? dqrely : RSqrt(uround);  /* Re-initialize nge */  pdata->nge = 0;  return(CVSPILS_SUCCESS);}

int CVodeSetStabLimDet(void *cvode_mem, booleantype sldet){  CVodeMem cv_mem;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetStabLimDet", MSGCV_NO_MEM);    return(CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if( sldet && (cv_mem->cv_lmm != CV_BDF) ) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetStabLimDet", MSGCV_SET_SLDET);    return(CV_ILL_INPUT);  }  cv_mem->cv_sldeton = sldet;  return(CV_SUCCESS);}

int CVodeSetIterType(void *cvode_mem, int iter){  CVodeMem cv_mem;  if (cvode_mem==NULL) {    CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetIterType", MSGCV_NO_MEM);    return(CV_MEM_NULL);  }  cv_mem = (CVodeMem) cvode_mem;  if ((iter != CV_FUNCTIONAL) && (iter != CV_NEWTON)) {    CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetIterType", MSGCV_BAD_ITER);    return (CV_ILL_INPUT);  }  cv_mem->cv_iter = iter;  return(CV_SUCCESS);}