```/* nag_inteq_fredholm2_smooth (d05abc) Example Program.
*
* Copyright 2017 Numerical Algorithms Group.
*
* Mark 26.2, 2017.
*/
#include <math.h>
#include <nag.h>
#include <nag_stdlib.h>
#include <nagc06.h>
#include <nagd05.h>
#include <nagx01.h>

#ifdef __cplusplus
extern "C"
{
#endif
static double NAG_CALL k(double x, double s, Nag_Comm *comm);
static double NAG_CALL g(double x, Nag_Comm *comm);
#ifdef __cplusplus
}
#endif

int main(void)
{
/* Scalars */
double a = -1.0, b = 1.0;
double lambda, x0;
Integer exit_status = 0;
Integer i, lx, n;
Nag_Boolean ev = Nag_TRUE, odorev = Nag_TRUE;
/* Arrays */
static double ruser[2] = { -1.0, -1.0 };
double *c = 0, *chebr = 0, *f = 0, *x = 0;
/* NAG types */
Nag_Comm comm;
NagError fail;
Nag_Series s = Nag_SeriesEven;

INIT_FAIL(fail);

printf("nag_inteq_fredholm2_smooth (d05abc) Example Program Results\n");

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

x0 = 0.5 * (a + b);

/* Set up uniform grid to evaluate Chebyshev polynomials. */
lx = (Integer) (4.000001 * (b - x0)) + 1;

if (!(x = NAG_ALLOC(lx, double)) || !(chebr = NAG_ALLOC(lx, double))
)
{
printf("Allocation failure\n");
exit_status = -1;
goto END;
}

x[0] = x0;
for (i = 1; i < lx; i++)
x[i] = x[i - 1] + 0.25;

printf("\nSolution is even\n");

lambda = -1.0 / nag_pi;

for (n = 5; n <= 10; n += 5) {
if (!(f = NAG_ALLOC(n, double)) || !(c = NAG_ALLOC(n, double))
)
{
printf("Allocation failure\n");
exit_status = -1;
goto END;
}

/*
nag_inteq_fredholm2_smooth (d05abc).
Linear non-singular Fredholm integral equation, second kind,
smooth kernel.
*/
nag_inteq_fredholm2_smooth(lambda, a, b, n, k, g, odorev, ev, f, c, &comm,
&fail);

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

printf("\nResults for n = %" NAG_IFMT "\n\n", n);
printf("Solution on first %2" NAG_IFMT " Chebyshev points and Chebyshev"
" coefficients\n", n);
printf("%3s%12s%18s%12s\n", "i", "x", "f[i]", "c[i]");
for (i = 0; i < n; i++) {
double y = cos(nag_pi * (double) (i) / (double) (2 * n - 1));
printf("%3" NAG_IFMT "%15.5f%15.5f%15.5e\n", i, y, f[i], c[i]);
}
printf("\n");

/*
Evaluate and print solution on uniform grid.
nag_sum_cheby_series (c06dcc).
Sum of a Chebyshev series at a set of points.
*/
nag_sum_cheby_series(x, lx, a, b, c, n, s, chebr, &fail);

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

printf("Solution on evenly spaced grid\n");
printf("\n     x           f(x)\n");
for (i = 0; i < lx; i++)
printf("%8.4f%15.5f\n", x[i], chebr[i]);
printf("\n");

NAG_FREE(c);
NAG_FREE(f);
}

END:

NAG_FREE(c);
NAG_FREE(f);
NAG_FREE(chebr);
NAG_FREE(x);

return exit_status;
}

static double NAG_CALL k(double x, double s, Nag_Comm *comm)
{
/* Scalars */
double alpha = 1.0;

if (comm->user[0] == -1.0) {
printf("(User-supplied callback k, first invocation.)\n");
comm->user[0] = 0.0;
}
return alpha / (pow(alpha, 2) + pow(x - s, 2));
}

static double NAG_CALL g(double x, Nag_Comm *comm)
{
if (comm->user[1] == -1.0) {
printf("(User-supplied callback g, first invocation.)\n");
comm->user[1] = 0.0;
}
return 1.0;
}
```