```/* nag_pde_dim1_parab_dae_fd (d03phc) Example Program.
*
* Copyright 2019 Numerical Algorithms Group.
*
* Mark 27.0, 2019.
*/

#include <stdio.h>
#include <math.h>
#include <nag.h>

#ifdef __cplusplus
extern "C"
{
#endif
static void NAG_CALL pdedef(Integer, double, double, const double[],
const double[], Integer, const double[],
const double[], double[], double[], double[],
Integer *, Nag_Comm *);
static void NAG_CALL bndary(Integer, double, const double[], const double[],
Integer, const double[], const double[],
Integer, double[], double[], Integer *,
Nag_Comm *);
static void NAG_CALL odedef(Integer, double, Integer, const double[],
const double[], Integer, const double[],
const double[], const double[], const double[],
const double[], const double[], double[],
Integer *, Nag_Comm *);
static void NAG_CALL uvinit(Integer, Integer, double *, double *, Integer,
Integer, double);
#ifdef __cplusplus
}
#endif

#define P(I, J)    p[npde*((J) -1)+(I) -1]
#define UCPX(I, J) ucpx[npde*((J) -1)+(I) -1]
#define UCP(I, J)  ucp[npde*((J) -1)+(I) -1]

int main(void)
{
/* Constants */
const Integer print_stat = 0;
const Integer npde = 1, npts = 121, ncode = 1, m = 0, nxi = 1;
const Integer neqn = npde*npts + ncode;
const Integer lisave = 24, lenode = 11*neqn + 50;
const Integer nwkres = neqn + npde*(6*nxi + 3*npde + 15) + nxi + 7*npts + 2;
const Integer lrsave = neqn*neqn + neqn + nwkres + lenode;
static double ruser[3] = { -1.0, -1.0, -1.0 };

/* Scalars */
double        tout, ts;
Integer       exit_status = 0, i, ind, it, itask, itol, itrace;

/* Arrays */
double        *algopt = 0, *atol = 0, *rsave = 0, *rtol = 0;
double        *u = 0, *x = 0, *xi = 0;
Integer       *isave = 0;

/* Nag Types */
NagError      fail;
Nag_Boolean   theta;
Nag_Comm      comm;
Nag_D03_Save  saved;

INIT_FAIL(fail);

printf("nag_pde_dim1_parab_dae_fd (d03phc) Example Program Results\n\n");

/* For communication with user-supplied functions: */
comm.user = ruser;

/* Allocate memory */

if (!(algopt = NAG_ALLOC(30, double)) ||
!(atol = NAG_ALLOC(1, double)) ||
!(rsave = NAG_ALLOC(lrsave, double)) ||
!(rtol = NAG_ALLOC(1, double)) ||
!(u = NAG_ALLOC(neqn, double)) ||
!(x = NAG_ALLOC(npts, double)) ||
!(xi = NAG_ALLOC(1, double)) ||
!(isave = NAG_ALLOC(lisave, Integer)))
{
printf("Allocation failure\n");
exit_status = 1;
goto END;
}

itrace = 0;
itol = 1;
atol[0] = 1e-6;
rtol[0] = atol[0];

/* Set break-points */

for (i = 0; i < npts; ++i) {
x[i] = i / (npts - 1.0);
}

xi[0] = 1.0;
ind = 0;

/* Set theta = TRUE if the Theta integrator is required */

theta = Nag_FALSE;
for (i = 0; i < 30; ++i)
algopt[i] = 0.0;
if (theta)
algopt[0] = 2.0;

/* Loop over output value of t */

printf("  Simple coupled PDE using BDF\n");
printf("  Accuracy requirement =%12.3e", atol[0]);
printf(" Number of points = %4" NAG_IFMT "\n\n", npts);
printf("%7s%8s%s\n", "time", "", "solution at x=0");

ts = 1e-4;
uvinit(npde, npts, x, u, npde, neqn, ts);

for (it = 0; it < 5; ++it) {
tout = 0.1 * pow(2.0, (it + 1.0));
/* nag_pde_dim1_parab_dae_fd (d03phc).
* General system of parabolic PDEs, coupled DAEs, method of
* lines, finite differences, one space variable
*/
nag_pde_dim1_parab_dae_fd(npde, m, &ts, tout, pdedef, bndary, u, npts, x,
ncode, odedef, nxi, xi, neqn, rtol, atol, itol,
Nag_TwoNorm, Nag_LinAlgFull, algopt, rsave,
lrsave, isave, lisave, itask, itrace, 0, &ind,
&comm, &saved, &fail);

if (fail.code != NE_NOERROR) {
printf("Error from nag_pde_dim1_parab_dae_fd (d03phc).\n%s\n",
fail.message);
exit_status = 1;
goto END;
}

printf("%7.1f%15s%6.2f\n", ts, "", u[0]);
}
if (print_stat) {
printf(" Number of integration steps in time = %6" NAG_IFMT "\n", isave[0]);
printf(" Number of function evaluations = %6" NAG_IFMT "\n", isave[1]);
printf(" Number of Jacobian evaluations =%6" NAG_IFMT "\n", isave[2]);
printf(" Number of iterations = %6" NAG_IFMT "\n\n", isave[4]);
}
END:
NAG_FREE(algopt);
NAG_FREE(atol);
NAG_FREE(rsave);
NAG_FREE(rtol);
NAG_FREE(u);
NAG_FREE(x);
NAG_FREE(xi);
NAG_FREE(isave);

return exit_status;
}

static void NAG_CALL pdedef(Integer npde, double t, double x,
const double u[], const double ux[],
Integer ncode, const double v[],
const double vdot[], double p[], double q[],
double r[], Integer *ires, Nag_Comm *comm)
{
if (comm->user[0] == -1.0) {
/* printf("(User-supplied callback pdedef, first invocation.)\n"); */
comm->user[0] = 0.0;
}
P(1, 1) = v[0] * v[0];
r[0] = ux[0];
q[0] = -(x) * ux[0] * v[0] * vdot[0];

return;
}

static void NAG_CALL bndary(Integer npde, double t, const double u[],
const double ux[], Integer ncode,
const double v[], const double vdot[],
Integer ibnd, double beta[], double gamma[],
Integer *ires, Nag_Comm *comm)
{
if (comm->user[1] == -1.0) {
/* printf("(User-supplied callback bndary, first invocation.)\n"); */
comm->user[1] = 0.0;
}
beta[0] = 1.0;
if (ibnd == 0) {
gamma[0] = -v[0] * exp(t);
}
else {
gamma[0] = -v[0] * vdot[0];
}
return;
}

static void NAG_CALL odedef(Integer npde, double t, Integer ncode,
const double v[], const double vdot[],
Integer nxi, const double xi[],
const double ucp[], const double ucpx[],
const double rcp[], const double ucpt[],
const double ucptx[], double f[], Integer *ires,
Nag_Comm *comm)
{
if (comm->user[2] == -1.0) {
/* printf("(User-supplied callback odedef, first invocation.)\n"); */
comm->user[2] = 0.0;
}
if (*ires == 1) {
f[0] = vdot[0] - v[0] * UCP(1, 1) - UCPX(1, 1) - 1.0 - t;
}
else if (*ires == -1) {
f[0] = vdot[0];
}
return;
}

static void NAG_CALL uvinit(Integer npde, Integer npts, double *x, double *u,
Integer ncode, Integer neqn, double ts)
{
/* Routine for PDE initial values */

Integer i;

for (i = 0; i < npts; ++i) {
u[i] = exp(ts * (1.0 - x[i])) - 1.0;
}
u[neqn - 1] = ts;

return;
}
```