```/* nag_opt_bounds_no_deriv (e04jbc) Example Program
*
* Copyright 2013 Numerical Algorithms Group.
*
* This example program demonstrates how to replace a call
* of e04jbc by a call of e04ucc. If you compile the example
* with the preprocessor macro E04JBC defined, it will call
* the superseded function e04jbc; otherwise it will call
* e04ucc. See mentions of E04JBC in the code below.
*
*/

#include <nag.h>
#include <math.h>
#include <stdio.h>
#include <nag_stdlib.h>
#include <nage04.h>
#include <nagx02.h>

#ifdef E04JBC
static void objfun(Integer n, double x[], double *f,
double g[], Nag_Comm *comm);
#else
static void objfun(Integer n, const double x[], double *objf,
double g[], Nag_Comm *comm);
#endif

int main(void)
{
Integer exit_status=0, n;
Integer nclin, ncnlin;
NagError fail;
#ifdef E04JBC
Nag_BoundType bound;
#endif
Nag_E04_Opt options;

double *bl=0, *bu=0, *g=0, objf, *x=0;
double a;

INIT_FAIL(fail);
Vprintf("e04jbc Example Program Results.\n");
n = 4;
if (n>=1)
{
if ( !( x = NAG_ALLOC(n, double)) ||
!( g = NAG_ALLOC(n, double)) ||
!( bl = NAG_ALLOC(n, double)) ||
!( bu = NAG_ALLOC(n, double)) )
{
Vprintf("Allocation failure\n");
exit_status = -1;
goto END;
}
}
else
{
Vprintf("Invalid n.\n");
exit_status = 1;
return exit_status;
}
x = 3.0;
x = -1.0;
x = 0.0;
x = 1.0;

/* Set bounds on variables */
#ifdef E04JBC
bound = Nag_Bounds;
#endif
bl = 1.0;
bu = 3.0;
bl = -2.0;
bu = 0.0;
/* x is not bounded, so we set bl to a large negative
* number and bu to a large positive number
*/
bl = -1.0e10;
bu = 1.0e10;
bl = 1.0;
bu = 3.0;

/* Call optimization routine */
#ifdef E04JBC
e04jbc(n, objfun, bound, bl, bu, x, &objf,
g, E04_DEFAULT, NAGCOMM_NULL, &fail);

if (fail.code != NE_NOERROR)
{
Vprintf("Error/Warning from e04jbc.\n%s\n", fail.message);
if (fail.code != NW_COND_MIN)
exit_status = 1;
goto END;
}
#else
/* Initialize and set options. */
e04xxc(&options);

/* State that our objfun does not compute derivatives of
objective or constraints */
options.obj_deriv = Nag_FALSE;
options.con_deriv = Nag_FALSE;

/* Accuracy required in objective function */
options.optim_tol = 1.0e-5;

/* Print full iterations and solution. */
options.print_level = Nag_Soln_Iter_Full;

/* Perform a maximum of 40 iterations */
options.max_iter = 40;

/* Estimate that the minimum lies within 4 units of start */
options.step_limit = 4.0;

/* Solve the problem. */
nclin=0;
ncnlin=0;

e04ucc(n, nclin, ncnlin, a, 1, bl, bu, objfun, NULLFN, x, &objf,
g, &options, NAGCOMM_NULL, &fail);

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

e04xzc(&options, "all", &fail);
if (fail.code != NE_NOERROR)
{
Vprintf("Memory freeing failed.\n%s\n", fail.message);
exit_status = 1;
}
#endif
END:
if (x) NAG_FREE(x);
if (g) NAG_FREE(g);
if (bl) NAG_FREE(bl);
if (bu) NAG_FREE(bu);
return exit_status;

}

#ifdef E04JBC
static void objfun(Integer n, double x[], double *objf,
double g[], Nag_Comm *comm)
#else
static void objfun(Integer n, const double x[], double *objf,
double g[], Nag_Comm *comm)
#endif
{
/* Routine to evaluate objective function. */

double a, b, c, d, x1, x2, x3, x4;

x1 = x;
x2 = x;
x3 = x;
x4 = x;

/* Supply a single function value */
a = x1 + 10.0*x2;
b = x3 - x4;
c = x2 - 2.0*x3, c *= c;
d = x1 - x4, d *= d;
*objf = a*a + 5.0*b*b + c*c + 10.0*d*d;
} /* objfun */
```