nlopt_result
NLOPT_STDCALL nlopt_add_inequality_mconstraint(nlopt_opt opt, unsigned m,
nlopt_mfunc fc, void *fc_data,
const double *tol)
{
nlopt_result ret;
if (!m) { /* empty constraints are always ok */
if (opt && opt->munge_on_destroy) opt->munge_on_destroy(fc_data);
return NLOPT_SUCCESS;
}
if (!opt || !inequality_ok(opt->algorithm)) ret = NLOPT_INVALID_ARGS;
else ret = add_constraint(&opt->m, &opt->m_alloc, &opt->fc,
m, NULL, fc, NULL, fc_data, tol);
if (ret < 0 && opt && opt->munge_on_destroy)
opt->munge_on_destroy(fc_data);
return ret;
}
nlopt_result
NLOPT_STDCALL nlopt_add_inequality_constraint(nlopt_opt opt,
nlopt_func fc, void *fc_data,
double tol)
{
nlopt_result ret;
if (!opt || !inequality_ok(opt->algorithm)) ret = NLOPT_INVALID_ARGS;
else ret = add_constraint(&opt->m, &opt->m_alloc, &opt->fc,
1, fc, NULL, fc_data, &tol);
if (ret < 0 && opt && opt->munge_on_destroy)
opt->munge_on_destroy(fc_data);
return ret;
}
nlopt_result NLOPT_STDCALL nlopt_set_max_objective(nlopt_opt opt,
nlopt_func f, void *f_data)
{
if (opt) {
if (opt->munge_on_destroy) opt->munge_on_destroy(opt->f_data);
opt->f = f; opt->f_data = f_data;
opt->maximize = 1;
if (nlopt_isinf(opt->stopval) && opt->stopval < 0)
opt->stopval = +HUGE_VAL; /* switch default from min to max */
return NLOPT_SUCCESS;
}
return NLOPT_INVALID_ARGS;
}
nlopt_result NLOPT_STDCALL nlopt_set_precond_min_objective(nlopt_opt opt,
nlopt_func f,
nlopt_precond pre,
void *f_data)
{
if (opt) {
if (opt->munge_on_destroy) opt->munge_on_destroy(opt->f_data);
opt->f = f; opt->f_data = f_data; opt->pre = pre;
opt->maximize = 0;
if (nlopt_isinf(opt->stopval) && opt->stopval > 0)
opt->stopval = -HUGE_VAL; /* switch default from max to min */
return NLOPT_SUCCESS;
}
return NLOPT_INVALID_ARGS;
}
nlopt_result
NLOPT_STDCALL nlopt_add_precond_equality_constraint(nlopt_opt opt,
nlopt_func fc,
nlopt_precond pre,
void *fc_data,
double tol)
{
nlopt_result ret;
if (!opt || !equality_ok(opt->algorithm)
|| nlopt_count_constraints(opt->p, opt->h) + 1 > opt->n)
ret = NLOPT_INVALID_ARGS;
else ret = add_constraint(&opt->p, &opt->p_alloc, &opt->h,
1, fc, NULL, pre, fc_data, &tol);
if (ret < 0 && opt && opt->munge_on_destroy)
opt->munge_on_destroy(fc_data);
return ret;
}
/* unlike nlopt_optimize() below, only handles minimization case */
static nlopt_result nlopt_optimize_(nlopt_opt opt, double *x, double *minf)
{
const double *lb, *ub;
nlopt_algorithm algorithm;
nlopt_func f; void *f_data;
unsigned n, i;
int ni;
nlopt_stopping stop;
if (!opt || !x || !minf || !opt->f
|| opt->maximize) return NLOPT_INVALID_ARGS;
/* reset stopping flag */
nlopt_set_force_stop(opt, 0);
opt->force_stop_child = NULL;
/* copy a few params to local vars for convenience */
n = opt->n;
ni = (int) n; /* most of the subroutines take "int" arg */
lb = opt->lb; ub = opt->ub;
algorithm = opt->algorithm;
f = opt->f; f_data = opt->f_data;
if (n == 0) { /* trivial case: no degrees of freedom */
*minf = opt->f(n, x, NULL, opt->f_data);
return NLOPT_SUCCESS;
}
*minf = HUGE_VAL;
/* make sure rand generator is inited */
nlopt_srand_time_default(); /* default is non-deterministic */
/* check bound constraints */
for (i = 0; i < n; ++i)
if (lb[i] > ub[i] || x[i] < lb[i] || x[i] > ub[i])
return NLOPT_INVALID_ARGS;
stop.n = n;
stop.minf_max = opt->stopval;
stop.ftol_rel = opt->ftol_rel;
stop.ftol_abs = opt->ftol_abs;
stop.xtol_rel = opt->xtol_rel;
stop.xtol_abs = opt->xtol_abs;
stop.nevals = 0;
stop.maxeval = opt->maxeval;
stop.maxtime = opt->maxtime;
stop.start = nlopt_seconds();
stop.force_stop = &(opt->force_stop);
switch (algorithm) {
case NLOPT_GN_DIRECT:
case NLOPT_GN_DIRECT_L:
case NLOPT_GN_DIRECT_L_RAND:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return cdirect(ni, f, f_data,
lb, ub, x, minf, &stop, 0.0,
(algorithm != NLOPT_GN_DIRECT)
+ 3 * (algorithm == NLOPT_GN_DIRECT_L_RAND
? 2 : (algorithm != NLOPT_GN_DIRECT))
+ 9 * (algorithm == NLOPT_GN_DIRECT_L_RAND
? 1 : (algorithm != NLOPT_GN_DIRECT)));
case NLOPT_GN_DIRECT_NOSCAL:
case NLOPT_GN_DIRECT_L_NOSCAL:
case NLOPT_GN_DIRECT_L_RAND_NOSCAL:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return cdirect_unscaled(ni, f, f_data, lb, ub, x, minf,
&stop, 0.0,
(algorithm != NLOPT_GN_DIRECT)
+ 3 * (algorithm == NLOPT_GN_DIRECT_L_RAND ? 2 : (algorithm != NLOPT_GN_DIRECT))
+ 9 * (algorithm == NLOPT_GN_DIRECT_L_RAND ? 1 : (algorithm != NLOPT_GN_DIRECT)));
case NLOPT_GN_ORIG_DIRECT:
case NLOPT_GN_ORIG_DIRECT_L: {
direct_return_code dret;
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
opt->work = malloc(sizeof(double) *
nlopt_max_constraint_dim(opt->m,
opt->fc));
if (!opt->work) return NLOPT_OUT_OF_MEMORY;
dret = direct_optimize(f_direct, opt, ni, lb, ub, x, minf,
stop.maxeval, -1,
stop.start, stop.maxtime,
0.0, 0.0,
pow(stop.xtol_rel, (double) n), -1.0,
stop.force_stop,
stop.minf_max, 0.0,
NULL,
algorithm == NLOPT_GN_ORIG_DIRECT
? DIRECT_ORIGINAL
: DIRECT_GABLONSKY);
free(opt->work); opt->work = NULL;
switch (dret) {
case DIRECT_INVALID_BOUNDS:
case DIRECT_MAXFEVAL_TOOBIG:
case DIRECT_INVALID_ARGS:
return NLOPT_INVALID_ARGS;
case DIRECT_INIT_FAILED:
case DIRECT_SAMPLEPOINTS_FAILED:
case DIRECT_SAMPLE_FAILED:
return NLOPT_FAILURE;
case DIRECT_MAXFEVAL_EXCEEDED:
case DIRECT_MAXITER_EXCEEDED:
return NLOPT_MAXEVAL_REACHED;
case DIRECT_MAXTIME_EXCEEDED:
return NLOPT_MAXTIME_REACHED;
case DIRECT_GLOBAL_FOUND:
return NLOPT_MINF_MAX_REACHED;
case DIRECT_VOLTOL:
case DIRECT_SIGMATOL:
return NLOPT_XTOL_REACHED;
case DIRECT_OUT_OF_MEMORY:
return NLOPT_OUT_OF_MEMORY;
case DIRECT_FORCED_STOP:
return NLOPT_FORCED_STOP;
}
break;
}
case NLOPT_GD_STOGO:
case NLOPT_GD_STOGO_RAND:
#ifdef WITH_CXX
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
if (!stogo_minimize(ni, f, f_data, x, minf, lb, ub, &stop,
algorithm == NLOPT_GD_STOGO
? 0 : (int) POP(2*n)))
return NLOPT_FAILURE;
break;
#else
return NLOPT_INVALID_ARGS;
#endif
#if 0
/* lacking a free/open-source license, we no longer use
Rowan's code, and instead use by "sbplx" re-implementation */
case NLOPT_LN_SUBPLEX: {
int iret, freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
iret = nlopt_subplex(f_bound, minf, x, n, opt, &stop, opt->dx);
if (freedx) { free(opt->dx); opt->dx = NULL; }
switch (iret) {
case -2: return NLOPT_INVALID_ARGS;
case -20: return NLOPT_FORCED_STOP;
case -10: return NLOPT_MAXTIME_REACHED;
case -1: return NLOPT_MAXEVAL_REACHED;
case 0: return NLOPT_XTOL_REACHED;
case 1: return NLOPT_SUCCESS;
case 2: return NLOPT_MINF_MAX_REACHED;
case 20: return NLOPT_FTOL_REACHED;
case -200: return NLOPT_OUT_OF_MEMORY;
default: return NLOPT_FAILURE; /* unknown return code */
}
break;
}
#endif
case NLOPT_LN_PRAXIS: {
double step;
if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
return praxis_(0.0, DBL_EPSILON,
step, ni, x, f_bound, opt, &stop, minf);
}
case NLOPT_LD_LBFGS:
return luksan_plis(ni, f, f_data, lb, ub, x, minf,
&stop, opt->vector_storage);
case NLOPT_LD_VAR1:
case NLOPT_LD_VAR2:
return luksan_plip(ni, f, f_data, lb, ub, x, minf,
&stop, opt->vector_storage,
algorithm == NLOPT_LD_VAR1 ? 1 : 2);
case NLOPT_LD_TNEWTON:
case NLOPT_LD_TNEWTON_RESTART:
case NLOPT_LD_TNEWTON_PRECOND:
case NLOPT_LD_TNEWTON_PRECOND_RESTART:
return luksan_pnet(ni, f, f_data, lb, ub, x, minf,
&stop, opt->vector_storage,
1 + (algorithm - NLOPT_LD_TNEWTON) % 2,
1 + (algorithm - NLOPT_LD_TNEWTON) / 2);
case NLOPT_GN_CRS2_LM:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return crs_minimize(ni, f, f_data, lb, ub, x, minf, &stop,
(int) POP(0), 0);
case NLOPT_G_MLSL:
case NLOPT_G_MLSL_LDS:
case NLOPT_GN_MLSL:
case NLOPT_GD_MLSL:
case NLOPT_GN_MLSL_LDS:
case NLOPT_GD_MLSL_LDS: {
nlopt_opt local_opt = opt->local_opt;
nlopt_result ret;
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
if (!local_opt && (algorithm == NLOPT_G_MLSL
|| algorithm == NLOPT_G_MLSL_LDS))
return NLOPT_INVALID_ARGS;
if (!local_opt) { /* default */
nlopt_algorithm local_alg = (algorithm == NLOPT_GN_MLSL ||
algorithm == NLOPT_GN_MLSL_LDS)
? nlopt_local_search_alg_nonderiv
: nlopt_local_search_alg_deriv;
/* don't call MLSL recursively! */
if (local_alg >= NLOPT_GN_MLSL
&& local_alg <= NLOPT_GD_MLSL_LDS)
local_alg = (algorithm == NLOPT_GN_MLSL ||
algorithm == NLOPT_GN_MLSL_LDS)
? NLOPT_LN_COBYLA : NLOPT_LD_MMA;
local_opt = nlopt_create(local_alg, n);
if (!local_opt) return NLOPT_FAILURE;
nlopt_set_ftol_rel(local_opt, opt->ftol_rel);
nlopt_set_ftol_abs(local_opt, opt->ftol_abs);
nlopt_set_xtol_rel(local_opt, opt->xtol_rel);
nlopt_set_xtol_abs(local_opt, opt->xtol_abs);
nlopt_set_maxeval(local_opt, nlopt_local_search_maxeval);
}
if (opt->dx) nlopt_set_initial_step(local_opt, opt->dx);
for (i = 0; i < n && stop.xtol_abs[i] > 0; ++i) ;
if (local_opt->ftol_rel <= 0 && local_opt->ftol_abs <= 0 &&
local_opt->xtol_rel <= 0 && i < n) {
/* it is not sensible to call MLSL without *some*
nonzero tolerance for the local search */
nlopt_set_ftol_rel(local_opt, 1e-15);
nlopt_set_xtol_rel(local_opt, 1e-7);
}
opt->force_stop_child = local_opt;
ret = mlsl_minimize(ni, f, f_data, lb, ub, x, minf, &stop,
local_opt, (int) POP(0),
algorithm >= NLOPT_GN_MLSL_LDS &&
algorithm != NLOPT_G_MLSL);
opt->force_stop_child = NULL;
if (!opt->local_opt) nlopt_destroy(local_opt);
return ret;
}
case NLOPT_LD_MMA: case NLOPT_LD_CCSAQ: {
nlopt_opt dual_opt;
nlopt_result ret;
#define LO(param, def) (opt->local_opt ? opt->local_opt->param : (def))
dual_opt = nlopt_create(LO(algorithm,
nlopt_local_search_alg_deriv),
nlopt_count_constraints(opt->m,
opt->fc));
if (!dual_opt) return NLOPT_FAILURE;
nlopt_set_ftol_rel(dual_opt, LO(ftol_rel, 1e-14));
nlopt_set_ftol_abs(dual_opt, LO(ftol_abs, 0.0));
nlopt_set_maxeval(dual_opt, LO(maxeval, 100000));
#undef LO
if (algorithm == NLOPT_LD_MMA)
ret = mma_minimize(n, f, f_data, opt->m, opt->fc,
lb, ub, x, minf, &stop, dual_opt);
else
ret = ccsa_quadratic_minimize(
n, f, f_data, opt->m, opt->fc, opt->pre,
lb, ub, x, minf, &stop, dual_opt);
nlopt_destroy(dual_opt);
return ret;
}
case NLOPT_LN_COBYLA: {
nlopt_result ret;
int freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
return cobyla_minimize(n, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop,
opt->dx);
if (freedx) { free(opt->dx); opt->dx = NULL; }
return ret;
}
case NLOPT_LN_NEWUOA: {
double step;
if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
return newuoa(ni, 2*n+1, x, 0, 0, step,
&stop, minf, f_noderiv, opt);
}
case NLOPT_LN_NEWUOA_BOUND: {
double step;
if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
return newuoa(ni, 2*n+1, x, lb, ub, step,
&stop, minf, f_noderiv, opt);
}
case NLOPT_LN_BOBYQA: {
nlopt_result ret;
int freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
ret = bobyqa(ni, 2*n+1, x, lb, ub, opt->dx,
&stop, minf, opt->f, opt->f_data);
if (freedx) { free(opt->dx); opt->dx = NULL; }
return ret;
}
case NLOPT_LN_NELDERMEAD:
case NLOPT_LN_SBPLX:
{
nlopt_result ret;
int freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
if (algorithm == NLOPT_LN_NELDERMEAD)
ret= nldrmd_minimize(ni,f,f_data,lb,ub,x,minf,opt->dx,&stop);
else
ret= sbplx_minimize(ni,f,f_data,lb,ub,x,minf,opt->dx,&stop);
if (freedx) { free(opt->dx); opt->dx = NULL; }
return ret;
}
case NLOPT_AUGLAG:
case NLOPT_AUGLAG_EQ:
case NLOPT_LN_AUGLAG:
case NLOPT_LN_AUGLAG_EQ:
case NLOPT_LD_AUGLAG:
case NLOPT_LD_AUGLAG_EQ: {
nlopt_opt local_opt = opt->local_opt;
nlopt_result ret;
if ((algorithm == NLOPT_AUGLAG || algorithm == NLOPT_AUGLAG_EQ)
&& !local_opt)
return NLOPT_INVALID_ARGS;
if (!local_opt) { /* default */
local_opt = nlopt_create(
algorithm == NLOPT_LN_AUGLAG ||
algorithm == NLOPT_LN_AUGLAG_EQ
? nlopt_local_search_alg_nonderiv
: nlopt_local_search_alg_deriv, n);
if (!local_opt) return NLOPT_FAILURE;
nlopt_set_ftol_rel(local_opt, opt->ftol_rel);
nlopt_set_ftol_abs(local_opt, opt->ftol_abs);
nlopt_set_xtol_rel(local_opt, opt->xtol_rel);
nlopt_set_xtol_abs(local_opt, opt->xtol_abs);
nlopt_set_maxeval(local_opt, nlopt_local_search_maxeval);
}
if (opt->dx) nlopt_set_initial_step(local_opt, opt->dx);
opt->force_stop_child = local_opt;
ret = auglag_minimize(ni, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop,
local_opt,
algorithm == NLOPT_AUGLAG_EQ
|| algorithm == NLOPT_LN_AUGLAG_EQ
|| algorithm == NLOPT_LD_AUGLAG_EQ);
opt->force_stop_child = NULL;
if (!opt->local_opt) nlopt_destroy(local_opt);
return ret;
}
case NLOPT_GN_ISRES:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return isres_minimize(ni, f, f_data,
(int) (opt->m), opt->fc,
(int) (opt->p), opt->h,
lb, ub, x, minf, &stop,
(int) POP(0));
// case NLOPT_GN_ESCH:
// if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
// return chevolutionarystrategy(n, f, f_data,
// lb, ub, x, minf, &stop,
// (unsigned) POP(0),
// (unsigned) (POP(0)*1.5));
case NLOPT_LD_SLSQP:
return nlopt_slsqp(n, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop);
default:
return NLOPT_INVALID_ARGS;
}
return NLOPT_SUCCESS; /* never reached */
}
/* unlike nlopt_optimize() below, only handles minimization case */
static nlopt_result nlopt_optimize_(nlopt_opt opt, double *x, double *minf)
{
const double *lb, *ub;
nlopt_algorithm algorithm;
nlopt_func f; void *f_data;
unsigned n, i;
int ni;
nlopt_stopping stop;
if (!opt || !x || !minf || !opt->f
|| opt->maximize) RETURN_ERR(NLOPT_INVALID_ARGS, opt,
"NULL args to nlopt_optimize_");
/* reset stopping flag */
nlopt_set_force_stop(opt, 0);
opt->force_stop_child = NULL;
/* copy a few params to local vars for convenience */
n = opt->n;
ni = (int) n; /* most of the subroutines take "int" arg */
lb = opt->lb; ub = opt->ub;
algorithm = opt->algorithm;
f = opt->f; f_data = opt->f_data;
if (n == 0) { /* trivial case: no degrees of freedom */
*minf = opt->f(n, x, NULL, opt->f_data);
return NLOPT_SUCCESS;
}
*minf = HUGE_VAL;
/* check bound constraints */
for (i = 0; i < n; ++i)
if (lb[i] > ub[i] || x[i] < lb[i] || x[i] > ub[i]) {
nlopt_set_errmsg(opt, "bounds %d fail %g <= %g <= %g",
i, lb[i], x[i], ub[i]);
return NLOPT_INVALID_ARGS;
}
stop.n = n;
stop.minf_max = opt->stopval;
stop.ftol_rel = opt->ftol_rel;
stop.ftol_abs = opt->ftol_abs;
stop.xtol_rel = opt->xtol_rel;
stop.xtol_abs = opt->xtol_abs;
stop.nevals = 0;
stop.maxeval = opt->maxeval;
stop.maxtime = opt->maxtime;
stop.force_stop = &(opt->force_stop);
stop.stop_msg = &(opt->errmsg);
switch (algorithm) {
case NLOPT_LD_SLSQP:
return nlopt_slsqp(n, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop);
default:
return NLOPT_INVALID_ARGS;
}
return NLOPT_SUCCESS; /* never reached */
}