```/* nag_opt_handle_set_get_real (e04rxc) Example Program.
*
* Copyright 2020 Numerical Algorithms Group.
*
* Mark 27.1, 2020.
*/

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

#ifdef __cplusplus
extern "C" {
#endif
static void NAG_CALL monit(void *handle, const double rinfo[],
const double stats[], Nag_Comm *comm,
Integer *inform);
#ifdef __cplusplus
}
#endif

int main(void) {

Integer nclin, nvar, nnza, nnzc, nnzu, exit_status, i, idlc;
Integer *irowa = 0, *icola = 0;
Integer iuser[1];
double *cvec = 0, *a = 0, *bla = 0, *bua = 0, *xl = 0, *xu = 0, *x = 0,
*u = 0;
double rinfo[100], stats[100];
void *handle = 0;
/* Nag Types */
Nag_Comm comm;
NagError fail;

exit_status = 0;

printf("nag_opt_handle_set_get_real (e04rxc) Example Program Results\n\n");
fflush(stdout);

/* Read the data file and allocate memory */
scanf(" %*[^\n]"); /* Skip heading in data file */
scanf("%" NAG_IFMT " %" NAG_IFMT " %" NAG_IFMT " %" NAG_IFMT " %*[^\n]",
&nclin, &nvar, &nnza, &nnzc);
/* Allocate memory */
nnzu = 2 * nvar + 2 * nclin;
if (!(irowa = NAG_ALLOC(nnza, Integer)) ||
!(icola = NAG_ALLOC(nnza, Integer)) ||
!(cvec = NAG_ALLOC(nnzc, double)) || !(a = NAG_ALLOC(nnza, double)) ||
!(bla = NAG_ALLOC(nclin, double)) || !(bua = NAG_ALLOC(nclin, double)) ||
!(xl = NAG_ALLOC(nvar, double)) || !(xu = NAG_ALLOC(nvar, double)) ||
!(x = NAG_ALLOC(nvar, double)) || !(u = NAG_ALLOC(nnzu, double))) {
printf("Allocation failure\n");
exit_status = -1;
goto END;
}
for (i = 0; i < nvar; i++) {
x[i] = 0.0;
}

for (i = 0; i < nnzc; i++) {
scanf("%lf", &cvec[i]);
}
scanf("%*[^\n]");
/* Read constraint matrix row indices */
for (i = 0; i < nnza; i++) {
scanf("%" NAG_IFMT, &irowa[i]);
}
scanf("%*[^\n]");
/* Read constraint matrix col indices */
for (i = 0; i < nnza; i++) {
scanf("%" NAG_IFMT, &icola[i]);
}
scanf("%*[^\n]");
/* Read constraint matrix values */
for (i = 0; i < nnza; i++) {
scanf("%lf", &a[i]);
}
scanf("%*[^\n]");
/* Read linear constraints lower bounds */
for (i = 0; i < nclin; i++) {
scanf("%lf ", &bla[i]);
}
scanf("%*[^\n]");
/* Read linear constraints upper bounds */
for (i = 0; i < nclin; i++) {
scanf("%lf ", &bua[i]);
}
scanf("%*[^\n]");
/* Read variables lower bounds */
for (i = 0; i < nvar; i++) {
scanf("%lf ", &xl[i]);
}
scanf("%*[^\n]");
/* Read variables upper bounds */
for (i = 0; i < nvar; i++) {
scanf("%lf ", &xu[i]);
}
scanf("%*[^\n]");

/* Create the problem handle */
/* nag_opt_handle_init (e04rac).
* Initialize an empty problem handle with NVAR variables. */
nag_opt_handle_init(&handle, nvar, NAGERR_DEFAULT);

/* nag_opt_handle_set_linobj (e04rec)
* Define a linear objective */
nag_opt_handle_set_linobj(handle, nvar, cvec, NAGERR_DEFAULT);

/* nag_opt_handle_set_simplebounds (e04rhc)
* Define bounds on the variables */
nag_opt_handle_set_simplebounds(handle, nvar, xl, xu, NAGERR_DEFAULT);

/* nag_opt_handle_set_linconstr (e04rjc)
* Define linear constraints */
idlc = 0;
nag_opt_handle_set_linconstr(handle, nclin, bla, bua, nnza, irowa, icola, a,
&idlc, NAGERR_DEFAULT);

/* nag_opt_handle_opt_set (e04zmc)
* Require printing of the solution at the end of the solve
*/
nag_opt_handle_opt_set(handle, "Print Solution = Yes", NAGERR_DEFAULT);
/* Use a constant number of centrality correctors steps */
nag_opt_handle_opt_set(handle, "LPIPM Centrality Correctors = -6",
NAGERR_DEFAULT);
/* Turn on monitoring */
nag_opt_handle_opt_set(handle, "LPIPM Monitor Frequency = 1", NAGERR_DEFAULT);
/* Print the solution at the end of the solve */
nag_opt_handle_opt_set(handle, "Print Solution = X", NAGERR_DEFAULT);
comm.iuser = iuser;
iuser[0] = nvar;

INIT_FAIL(fail);
/* nag_opt_handle_solve_lp_ipm (e04mtc)
* Call LP interior point solver with the primal-dual algorithm */
nag_opt_handle_solve_lp_ipm(handle, nvar, x, nnzu, u, rinfo, stats, monit,
&comm, &fail);
if (fail.code != NE_NOERROR) {
printf("Error from nag_opt_handle_solve_lp_ipm (e04mtc).\n%s\n",
fail.message);
exit_status = 1;
}

END:
NAG_FREE(cvec);
NAG_FREE(irowa);
NAG_FREE(icola);
NAG_FREE(a);
NAG_FREE(bla);
NAG_FREE(bua);
NAG_FREE(xl);
NAG_FREE(xu);
NAG_FREE(x);
NAG_FREE(u);
/* nag_opt_handle_free (e04rzc).
* Destroy the problem handle and deallocate all the memory. */
if (handle)
nag_opt_handle_free(&handle, NAGERR_DEFAULT);

return exit_status;
}

static void NAG_CALL monit(void *handle, const double rinfo[],
const double stats[], Nag_Comm *comm,
Integer *inform) {
/* Monitoring function */
double tol = 1.0e-03;
Integer nvar, i;
double *x = 0;

if (!comm || !comm->iuser) {
/* The communication structure is not correctly allocated, abort solve */
*inform = -1;
return;
}

nvar = comm->iuser[0];

/* Allocate memory */
if (!(x = NAG_ALLOC(nvar, double))) {
printf("Allocation failure\n");
*inform = -1;
return;
}

/* x is close to the solution, extract the values with
* nag_opt_handle_set_get_real (e04rxc) and print it
*/
if (rinfo[4] < tol && rinfo[5] < tol && rinfo[6] < tol) {
nag_opt_handle_set_get_real(handle, "Primal Variables", 1, &nvar, x,
NAGERR_DEFAULT);
printf("\n");
printf("     monit() reports good approximate solution "
"(tol =, %8.2e):\n",
tol);
for (i = 0; i < nvar; i++) {
printf("       X%1" NAG_IFMT ": %9.2e\n", i + 1, x[i]);
}
printf("     end of monit()\n");
}
fflush(stdout);
NAG_FREE(x);
}
```