nlopt_result cdirect_hybrid_unscaled(int n, nlopt_func f, void *f_data,
const double *lb, const double *ub,
double *x,
double *minf,
nlopt_stopping *stop,
nlopt_algorithm local_alg,
int local_maxeval,
int randomized_div)
{
params p;
int i;
double *rnew;
nlopt_result ret = NLOPT_OUT_OF_MEMORY;
p.n = n;
p.L = 3*n+3;
p.lb = lb; p.ub = ub;
p.stop = stop;
p.f = f;
p.f_data = f_data;
p.minf = HUGE_VAL;
p.xmin = x;
p.age = 0;
p.work = 0;
p.local_alg = local_alg;
p.local_maxeval = local_maxeval;
p.randomized_div = randomized_div;
rb_tree_init(&p.rtree, cdirect_hyperrect_compare);
p.work = (double *) malloc(sizeof(double) * (2*n));
if (!p.work) goto done;
if (!(rnew = (double *) malloc(sizeof(double) * p.L))) goto done;
for (i = 0; i < n; ++i) {
rnew[3+i] = rnew[3+n+i] = 0.5 * (lb[i] + ub[i]);
rnew[3+2*n+i] = ub[i] - lb[i];
}
rnew[0] = longest(n, rnew+2*n);
rnew[2] = p.age--;
ret = optimize_rect(rnew, &p);
if (ret != NLOPT_SUCCESS) { free(rnew); goto done; }
if (!rb_tree_insert(&p.rtree, rnew)) { free(rnew); goto done; }
do {
ret = divide_largest(&p);
} while (ret == NLOPT_SUCCESS);
done:
rb_tree_destroy_with_keys(&p.rtree);
free(p.work);
*minf = p.minf;
return ret;
}
nlopt_result cdirect_unscaled(int n, nlopt_func f, void *f_data,
const double *lb, const double *ub,
double *x,
double *minf,
nlopt_stopping *stop,
double magic_eps, int which_alg)
{
params p;
int i;
double *rnew;
nlopt_result ret = NLOPT_OUT_OF_MEMORY;
p.magic_eps = magic_eps;
p.which_diam = which_alg % 3;
p.which_div = (which_alg / 3) % 3;
p.which_opt = (which_alg / (3*3)) % 3;
p.lb = lb; p.ub = ub;
p.stop = stop;
p.n = n;
p.L = 2*n+3;
p.f = f;
p.f_data = f_data;
p.xmin = x;
p.minf = HUGE_VAL;
p.work = 0;
p.iwork = 0;
p.hull = 0;
p.age = 0;
rb_tree_init(&p.rtree, cdirect_hyperrect_compare);
p.work = (double *) malloc(sizeof(double) * (2*n));
if (!p.work) goto done;
p.iwork = (int *) malloc(sizeof(int) * n);
if (!p.iwork) goto done;
p.hull_len = 128; /* start with a reasonable number */
p.hull = (double **) malloc(sizeof(double *) * p.hull_len);
if (!p.hull) goto done;
if (!(rnew = (double *) malloc(sizeof(double) * p.L))) goto done;
for (i = 0; i < n; ++i) {
rnew[3+i] = 0.5 * (lb[i] + ub[i]);
rnew[3+n+i] = ub[i] - lb[i];
}
rnew[0] = rect_diameter(n, rnew+3+n, &p);
rnew[1] = function_eval(rnew+3, &p);
rnew[2] = p.age++;
if (!rb_tree_insert(&p.rtree, rnew)) {
free(rnew);
goto done;
}
ret = divide_rect(rnew, &p);
if (ret != NLOPT_SUCCESS) goto done;
while (1) {
double minf0 = p.minf;
ret = divide_good_rects(&p);
if (ret != NLOPT_SUCCESS) goto done;
if (p.minf < minf0 && nlopt_stop_f(p.stop, p.minf, minf0)) {
ret = NLOPT_FTOL_REACHED;
goto done;
}
}
done:
rb_tree_destroy_with_keys(&p.rtree);
free(p.hull);
free(p.iwork);
free(p.work);
*minf = p.minf;
return ret;
}
nlopt_result mlsl_minimize(int n, nlopt_func f, void *f_data,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
nlopt_opt local_opt,
int Nsamples, /* #samples/iteration (0=default) */
int lds) /* random or low-discrepancy seq. (lds) */
{
nlopt_result ret = NLOPT_SUCCESS;
mlsl_data d;
int i;
pt *p;
if (!Nsamples)
d.N = 4; /* FIXME: what is good number of samples per iteration? */
else
d.N = Nsamples;
if (d.N < 1) return NLOPT_INVALID_ARGS;
d.n = n;
d.lb = lb; d.ub = ub;
d.stop = stop;
d.f = f; d.f_data = f_data;
rb_tree_init(&d.pts, pt_compare);
rb_tree_init(&d.lms, lm_compare);
d.s = lds ? nlopt_sobol_create((unsigned) n) : NULL;
nlopt_set_min_objective(local_opt, fcount, &d);
nlopt_set_lower_bounds(local_opt, lb);
nlopt_set_upper_bounds(local_opt, ub);
nlopt_set_stopval(local_opt, stop->minf_max);
d.gamma = MLSL_GAMMA;
d.R_prefactor = sqrt(2./K2PI) * pow(gam(n) * MLSL_SIGMA, 1.0/n);
for (i = 0; i < n; ++i)
d.R_prefactor *= pow(ub[i] - lb[i], 1.0/n);
/* MLSL also suggests setting some minimum distance from points
to previous local minimiza and to the boundaries; I don't know
how to choose this as a fixed number, so I set it proportional
to R; see also the comments at top. dlm and dbound are the
proportionality constants. */
d.dlm = 1.0; /* min distance/R to local minima (FIXME: good value?) */
d.dbound = 1e-6; /* min distance/R to ub/lb boundaries (good value?) */
p = alloc_pt(n);
if (!p) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
/* FIXME: how many sobol points to skip, if any? */
nlopt_sobol_skip(d.s, (unsigned) (10*n+d.N), p->x);
memcpy(p->x, x, n * sizeof(double));
p->f = f(n, x, NULL, f_data);
stop->nevals++;
if (!rb_tree_insert(&d.pts, (rb_key) p)) {
free(p); ret = NLOPT_OUT_OF_MEMORY;
}
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
else if (p->f < stop->minf_max) ret = NLOPT_MINF_MAX_REACHED;
while (ret == NLOPT_SUCCESS) {
rb_node *node;
double R;
get_minf(&d, minf, x);
/* sampling phase: add random/quasi-random points */
for (i = 0; i < d.N && ret == NLOPT_SUCCESS; ++i) {
p = alloc_pt(n);
if (!p) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
if (d.s) nlopt_sobol_next(d.s, p->x, lb, ub);
else { /* use random points instead of LDS */
int j;
for (j = 0; j < n; ++j) p->x[j] = nlopt_urand(lb[j],ub[j]);
}
p->f = f(n, p->x, NULL, f_data);
stop->nevals++;
if (!rb_tree_insert(&d.pts, (rb_key) p)) {
free(p); ret = NLOPT_OUT_OF_MEMORY;
}
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
else if (p->f < stop->minf_max) ret = NLOPT_MINF_MAX_REACHED;
else {
find_closest_pt(n, &d.pts, p);
find_closest_lm(n, &d.lms, p);
pts_update_newpt(n, &d.pts, p);
}
}
/* distance threshhold parameter R in MLSL */
R = d.R_prefactor
* pow(log((double) d.pts.N) / d.pts.N, 1.0 / n);
/* local search phase: do local opt. for promising points */
node = rb_tree_min(&d.pts);
for (i = (int) (ceil(d.gamma * d.pts.N) + 0.5);
node && i > 0 && ret == NLOPT_SUCCESS; --i) {
p = (pt *) node->k;
if (is_potential_minimizer(&d, p,
R, d.dlm*R, d.dbound*R)) {
nlopt_result lret;
double *lm;
double t = nlopt_seconds();
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; break;
}
if (nlopt_stop_evals(stop)) {
ret = NLOPT_MAXEVAL_REACHED; break;
}
if (stop->maxtime > 0 &&
t - stop->start >= stop->maxtime) {
ret = NLOPT_MAXTIME_REACHED; break;
}
lm = (double *) malloc(sizeof(double) * (n+1));
if (!lm) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
memcpy(lm+1, p->x, sizeof(double) * n);
lret = nlopt_optimize_limited(local_opt, lm+1, lm,
stop->maxeval - stop->nevals,
stop->maxtime -
(t - stop->start));
p->minimized = 1;
if (lret < 0) { free(lm); ret = lret; goto done; }
if (!rb_tree_insert(&d.lms, lm)) {
free(lm); ret = NLOPT_OUT_OF_MEMORY;
}
else if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (*lm < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
else if (nlopt_stop_evals(stop))
ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop))
ret = NLOPT_MAXTIME_REACHED;
else
pts_update_newlm(n, &d.pts, lm);
}
/* TODO: additional stopping criteria based
e.g. on improvement in function values, etc? */
node = rb_tree_succ(node);
}
}
get_minf(&d, minf, x);
done:
nlopt_sobol_destroy(d.s);
rb_tree_destroy_with_keys(&d.lms);
rb_tree_destroy_with_keys(&d.pts);
return ret;
}
