ts-aggregator/project_template/nlopt.hpp

597 lines
21 KiB
C++
Raw Permalink Normal View History

2022-12-13 12:36:06 +04:00
/* Copyright (c) 2007-2011 Massachusetts Institute of Technology
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
// C++ style wrapper around NLopt API
// nlopt.hpp is AUTOMATICALLY GENERATED from nlopt-in.hpp - edit the latter!
#ifndef NLOPT_HPP
#define NLOPT_HPP
#include "nlopt.h"
#include <vector>
#include <stdexcept>
#include <new>
#include <cstdlib>
#include <cstring>
#include <cmath>
// convenience overloading for below (not in nlopt:: since has nlopt_ prefix)
inline nlopt_result nlopt_get_initial_step(const nlopt_opt opt, double *dx) {
return nlopt_get_initial_step(opt, (const double *) NULL, dx);
}
namespace nlopt {
//////////////////////////////////////////////////////////////////////
// nlopt::* namespace versions of the C enumerated types
// AUTOMATICALLY GENERATED, DO NOT EDIT
// GEN_ENUMS_HERE
enum algorithm {
GN_DIRECT = 0,
GN_DIRECT_L,
GN_DIRECT_L_RAND,
GN_DIRECT_NOSCAL,
GN_DIRECT_L_NOSCAL,
GN_DIRECT_L_RAND_NOSCAL,
GN_ORIG_DIRECT,
GN_ORIG_DIRECT_L,
GD_STOGO,
GD_STOGO_RAND,
LD_LBFGS_NOCEDAL,
LD_LBFGS,
LN_PRAXIS,
LD_VAR1,
LD_VAR2,
LD_TNEWTON,
LD_TNEWTON_RESTART,
LD_TNEWTON_PRECOND,
LD_TNEWTON_PRECOND_RESTART,
GN_CRS2_LM,
GN_MLSL,
GD_MLSL,
GN_MLSL_LDS,
GD_MLSL_LDS,
LD_MMA,
LN_COBYLA,
LN_NEWUOA,
LN_NEWUOA_BOUND,
LN_NELDERMEAD,
LN_SBPLX,
LN_AUGLAG,
LD_AUGLAG,
LN_AUGLAG_EQ,
LD_AUGLAG_EQ,
LN_BOBYQA,
GN_ISRES,
AUGLAG,
AUGLAG_EQ,
G_MLSL,
G_MLSL_LDS,
LD_SLSQP,
LD_CCSAQ,
GN_ESCH,
NUM_ALGORITHMS /* not an algorithm, just the number of them */
};
enum result {
FAILURE = -1, /* generic failure code */
INVALID_ARGS = -2,
OUT_OF_MEMORY = -3,
ROUNDOFF_LIMITED = -4,
FORCED_STOP = -5,
SUCCESS = 1, /* generic success code */
STOPVAL_REACHED = 2,
FTOL_REACHED = 3,
XTOL_REACHED = 4,
MAXEVAL_REACHED = 5,
MAXTIME_REACHED = 6
};
// GEN_ENUMS_HERE
//////////////////////////////////////////////////////////////////////
typedef nlopt_func func; // nlopt::func synoynm
typedef nlopt_mfunc mfunc; // nlopt::mfunc synoynm
// alternative to nlopt_func that takes std::vector<double>
// ... unfortunately requires a data copy
typedef double (*vfunc)(const std::vector<double> &x,
std::vector<double> &grad, void *data);
//////////////////////////////////////////////////////////////////////
// NLopt-specific exceptions (corresponding to error codes):
class roundoff_limited : public std::runtime_error {
public:
roundoff_limited() : std::runtime_error("nlopt roundoff-limited") {}
};
class forced_stop : public std::runtime_error {
public:
forced_stop() : std::runtime_error("nlopt forced stop") {}
};
//////////////////////////////////////////////////////////////////////
class opt {
private:
nlopt_opt o;
void mythrow(nlopt_result ret) const {
switch (ret) {
case NLOPT_FAILURE: throw std::runtime_error("nlopt failure");
case NLOPT_OUT_OF_MEMORY: throw std::bad_alloc();
case NLOPT_INVALID_ARGS: throw std::invalid_argument("nlopt invalid argument");
case NLOPT_ROUNDOFF_LIMITED: throw roundoff_limited();
case NLOPT_FORCED_STOP: throw forced_stop();
default: break;
}
}
typedef struct {
opt *o;
mfunc mf; func f; void *f_data;
vfunc vf;
nlopt_munge munge_destroy, munge_copy; // non-NULL for SWIG wrappers
} myfunc_data;
// free/destroy f_data in nlopt_destroy and nlopt_copy, respectively
static void *free_myfunc_data(void *p) {
myfunc_data *d = (myfunc_data *) p;
if (d) {
if (d->f_data && d->munge_destroy) d->munge_destroy(d->f_data);
delete d;
}
return NULL;
}
static void *dup_myfunc_data(void *p) {
myfunc_data *d = (myfunc_data *) p;
if (d) {
void *f_data;
if (d->f_data && d->munge_copy) {
f_data = d->munge_copy(d->f_data);
if (!f_data) return NULL;
}
else
f_data = d->f_data;
myfunc_data *dnew = new myfunc_data;
if (dnew) {
*dnew = *d;
dnew->f_data = f_data;
}
return (void*) dnew;
}
else return NULL;
}
// nlopt_func wrapper that catches exceptions
static double myfunc(unsigned n, const double *x, double *grad, void *d_) {
myfunc_data *d = reinterpret_cast<myfunc_data*>(d_);
try {
return d->f(n, x, grad, d->f_data);
}
catch (std::bad_alloc&)
{ d->o->forced_stop_reason = NLOPT_OUT_OF_MEMORY; }
catch (std::invalid_argument&)
{ d->o->forced_stop_reason = NLOPT_INVALID_ARGS; }
catch (roundoff_limited&)
{ d->o->forced_stop_reason = NLOPT_ROUNDOFF_LIMITED; }
catch (forced_stop&)
{ d->o->forced_stop_reason = NLOPT_FORCED_STOP; }
catch (...)
{ d->o->forced_stop_reason = NLOPT_FAILURE; }
d->o->force_stop(); // stop gracefully, opt::optimize will re-throw
return HUGE_VAL;
}
// nlopt_mfunc wrapper that catches exceptions
static void mymfunc(unsigned m, double *result,
unsigned n, const double *x, double *grad, void *d_) {
myfunc_data *d = reinterpret_cast<myfunc_data*>(d_);
try {
d->mf(m, result, n, x, grad, d->f_data);
return;
}
catch (std::bad_alloc&)
{ d->o->forced_stop_reason = NLOPT_OUT_OF_MEMORY; }
catch (std::invalid_argument&)
{ d->o->forced_stop_reason = NLOPT_INVALID_ARGS; }
catch (roundoff_limited&)
{ d->o->forced_stop_reason = NLOPT_ROUNDOFF_LIMITED; }
catch (forced_stop&)
{ d->o->forced_stop_reason = NLOPT_FORCED_STOP; }
catch (...)
{ d->o->forced_stop_reason = NLOPT_FAILURE; }
d->o->force_stop(); // stop gracefully, opt::optimize will re-throw
for (unsigned i = 0; i < m; ++i) result[i] = HUGE_VAL;
}
std::vector<double> xtmp, gradtmp, gradtmp0; // scratch for myvfunc
// nlopt_func wrapper, using std::vector<double>
static double myvfunc(unsigned n, const double *x, double *grad, void *d_){
myfunc_data *d = reinterpret_cast<myfunc_data*>(d_);
try {
std::vector<double> &xv = d->o->xtmp;
if (n) std::memcpy(&xv[0], x, n * sizeof(double));
double val=d->vf(xv, grad ? d->o->gradtmp : d->o->gradtmp0, d->f_data);
if (grad && n) {
std::vector<double> &gradv = d->o->gradtmp;
std::memcpy(grad, &gradv[0], n * sizeof(double));
}
return val;
}
catch (std::bad_alloc&)
{ d->o->forced_stop_reason = NLOPT_OUT_OF_MEMORY; }
catch (std::invalid_argument&)
{ d->o->forced_stop_reason = NLOPT_INVALID_ARGS; }
catch (roundoff_limited&)
{ d->o->forced_stop_reason = NLOPT_ROUNDOFF_LIMITED; }
catch (forced_stop&)
{ d->o->forced_stop_reason = NLOPT_FORCED_STOP; }
catch (...)
{ d->o->forced_stop_reason = NLOPT_FAILURE; }
d->o->force_stop(); // stop gracefully, opt::optimize will re-throw
return HUGE_VAL;
}
void alloc_tmp() {
if (xtmp.size() != nlopt_get_dimension(o)) {
xtmp = std::vector<double>(nlopt_get_dimension(o));
gradtmp = std::vector<double>(nlopt_get_dimension(o));
}
}
result last_result;
double last_optf;
nlopt_result forced_stop_reason;
public:
// Constructors etc.
opt() : o(NULL), xtmp(0), gradtmp(0), gradtmp0(0),
last_result(nlopt::FAILURE), last_optf(HUGE_VAL),
forced_stop_reason(NLOPT_FORCED_STOP) {}
~opt() { nlopt_destroy(o); }
opt(algorithm a, unsigned n) :
o(nlopt_create(nlopt_algorithm(a), n)),
xtmp(0), gradtmp(0), gradtmp0(0),
last_result(nlopt::FAILURE), last_optf(HUGE_VAL),
forced_stop_reason(NLOPT_FORCED_STOP) {
if (!o) throw std::bad_alloc();
nlopt_set_munge(o, free_myfunc_data, dup_myfunc_data);
}
opt(const opt& f) : o(nlopt_copy(f.o)),
xtmp(f.xtmp), gradtmp(f.gradtmp), gradtmp0(0),
last_result(f.last_result), last_optf(f.last_optf),
forced_stop_reason(f.forced_stop_reason) {
if (f.o && !o) throw std::bad_alloc();
}
opt& operator=(opt const& f) {
if (this == &f) return *this; // self-assignment
nlopt_destroy(o);
o = nlopt_copy(f.o);
if (f.o && !o) throw std::bad_alloc();
xtmp = f.xtmp; gradtmp = f.gradtmp;
last_result = f.last_result; last_optf = f.last_optf;
forced_stop_reason = f.forced_stop_reason;
return *this;
}
// Do the optimization:
result optimize(std::vector<double> &x, double &opt_f) {
if (o && nlopt_get_dimension(o) != x.size())
throw std::invalid_argument("dimension mismatch");
forced_stop_reason = NLOPT_FORCED_STOP;
nlopt_result ret = nlopt_optimize(o, x.empty() ? NULL : &x[0], &opt_f);
last_result = result(ret);
last_optf = opt_f;
if (ret == NLOPT_FORCED_STOP)
mythrow(forced_stop_reason);
mythrow(ret);
return last_result;
}
// variant mainly useful for SWIG wrappers:
std::vector<double> optimize(const std::vector<double> &x0) {
std::vector<double> x(x0);
last_result = optimize(x, last_optf);
return x;
}
result last_optimize_result() const { return last_result; }
double last_optimum_value() const { return last_optf; }
// accessors:
algorithm get_algorithm() const {
if (!o) throw std::runtime_error("uninitialized nlopt::opt");
return algorithm(nlopt_get_algorithm(o));
}
const char *get_algorithm_name() const {
if (!o) throw std::runtime_error("uninitialized nlopt::opt");
return nlopt_algorithm_name(nlopt_get_algorithm(o));
}
unsigned get_dimension() const {
if (!o) throw std::runtime_error("uninitialized nlopt::opt");
return nlopt_get_dimension(o);
}
// Set the objective function
void set_min_objective(func f, void *f_data) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_set_min_objective(o, myfunc, d)); // d freed via o
}
void set_min_objective(vfunc vf, void *f_data) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = NULL; d->f_data = f_data; d->mf = NULL; d->vf = vf;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_set_min_objective(o, myvfunc, d)); // d freed via o
alloc_tmp();
}
void set_max_objective(func f, void *f_data) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_set_max_objective(o, myfunc, d)); // d freed via o
}
void set_max_objective(vfunc vf, void *f_data) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = NULL; d->f_data = f_data; d->mf = NULL; d->vf = vf;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_set_max_objective(o, myvfunc, d)); // d freed via o
alloc_tmp();
}
// for internal use in SWIG wrappers -- variant that
// takes ownership of f_data, with munging for destroy/copy
void set_min_objective(func f, void *f_data,
nlopt_munge md, nlopt_munge mc) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = md; d->munge_copy = mc;
mythrow(nlopt_set_min_objective(o, myfunc, d)); // d freed via o
}
void set_max_objective(func f, void *f_data,
nlopt_munge md, nlopt_munge mc) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = md; d->munge_copy = mc;
mythrow(nlopt_set_max_objective(o, myfunc, d)); // d freed via o
}
// Nonlinear constraints:
void remove_inequality_constraints() {
nlopt_result ret = nlopt_remove_inequality_constraints(o);
mythrow(ret);
}
void add_inequality_constraint(func f, void *f_data, double tol=0) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_add_inequality_constraint(o, myfunc, d, tol));
}
void add_inequality_constraint(vfunc vf, void *f_data, double tol=0) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = NULL; d->f_data = f_data; d->mf = NULL; d->vf = vf;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_add_inequality_constraint(o, myvfunc, d, tol));
alloc_tmp();
}
void add_inequality_mconstraint(mfunc mf, void *f_data,
const std::vector<double> &tol) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->mf = mf; d->f_data = f_data; d->f = NULL; d->vf = NULL;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_add_inequality_mconstraint(o, tol.size(), mymfunc, d,
tol.empty() ? NULL : &tol[0]));
}
void remove_equality_constraints() {
nlopt_result ret = nlopt_remove_equality_constraints(o);
mythrow(ret);
}
void add_equality_constraint(func f, void *f_data, double tol=0) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_add_equality_constraint(o, myfunc, d, tol));
}
void add_equality_constraint(vfunc vf, void *f_data, double tol=0) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = NULL; d->f_data = f_data; d->mf = NULL; d->vf = vf;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_add_equality_constraint(o, myvfunc, d, tol));
alloc_tmp();
}
void add_equality_mconstraint(mfunc mf, void *f_data,
const std::vector<double> &tol) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->mf = mf; d->f_data = f_data; d->f = NULL; d->vf = NULL;
d->munge_destroy = d->munge_copy = NULL;
mythrow(nlopt_add_equality_mconstraint(o, tol.size(), mymfunc, d,
tol.empty() ? NULL : &tol[0]));
}
// For internal use in SWIG wrappers (see also above)
void add_inequality_constraint(func f, void *f_data,
nlopt_munge md, nlopt_munge mc,
double tol=0) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = md; d->munge_copy = mc;
mythrow(nlopt_add_inequality_constraint(o, myfunc, d, tol));
}
void add_equality_constraint(func f, void *f_data,
nlopt_munge md, nlopt_munge mc,
double tol=0) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->f = f; d->f_data = f_data; d->mf = NULL; d->vf = NULL;
d->munge_destroy = md; d->munge_copy = mc;
mythrow(nlopt_add_equality_constraint(o, myfunc, d, tol));
}
void add_inequality_mconstraint(mfunc mf, void *f_data,
nlopt_munge md, nlopt_munge mc,
const std::vector<double> &tol) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->mf = mf; d->f_data = f_data; d->f = NULL; d->vf = NULL;
d->munge_destroy = md; d->munge_copy = mc;
mythrow(nlopt_add_inequality_mconstraint(o, tol.size(), mymfunc, d,
tol.empty() ? NULL : &tol[0]));
}
void add_equality_mconstraint(mfunc mf, void *f_data,
nlopt_munge md, nlopt_munge mc,
const std::vector<double> &tol) {
myfunc_data *d = new myfunc_data;
if (!d) throw std::bad_alloc();
d->o = this; d->mf = mf; d->f_data = f_data; d->f = NULL; d->vf = NULL;
d->munge_destroy = md; d->munge_copy = mc;
mythrow(nlopt_add_equality_mconstraint(o, tol.size(), mymfunc, d,
tol.empty() ? NULL : &tol[0]));
}
#define NLOPT_GETSET_VEC(name) \
void set_##name(double val) { \
mythrow(nlopt_set_##name##1(o, val)); \
} \
void get_##name(std::vector<double> &v) const { \
if (o && nlopt_get_dimension(o) != v.size()) \
throw std::invalid_argument("dimension mismatch"); \
mythrow(nlopt_get_##name(o, v.empty() ? NULL : &v[0])); \
} \
std::vector<double> get_##name() const { \
if (!o) throw std::runtime_error("uninitialized nlopt::opt"); \
std::vector<double> v(nlopt_get_dimension(o)); \
get_##name(v); \
return v; \
} \
void set_##name(const std::vector<double> &v) { \
if (o && nlopt_get_dimension(o) != v.size()) \
throw std::invalid_argument("dimension mismatch"); \
mythrow(nlopt_set_##name(o, v.empty() ? NULL : &v[0])); \
}
NLOPT_GETSET_VEC(lower_bounds)
NLOPT_GETSET_VEC(upper_bounds)
// stopping criteria:
#define NLOPT_GETSET(T, name) \
T get_##name() const { \
if (!o) throw std::runtime_error("uninitialized nlopt::opt"); \
return nlopt_get_##name(o); \
} \
void set_##name(T name) { \
mythrow(nlopt_set_##name(o, name)); \
}
NLOPT_GETSET(double, stopval)
NLOPT_GETSET(double, ftol_rel)
NLOPT_GETSET(double, ftol_abs)
NLOPT_GETSET(double, xtol_rel)
NLOPT_GETSET_VEC(xtol_abs)
NLOPT_GETSET(int, maxeval)
NLOPT_GETSET(double, maxtime)
NLOPT_GETSET(int, force_stop)
void force_stop() { set_force_stop(1); }
// algorithm-specific parameters:
void set_local_optimizer(const opt &lo) {
nlopt_result ret = nlopt_set_local_optimizer(o, lo.o);
mythrow(ret);
}
NLOPT_GETSET(unsigned, population)
NLOPT_GETSET(unsigned, vector_storage)
NLOPT_GETSET_VEC(initial_step)
void set_default_initial_step(const std::vector<double> &x) {
nlopt_result ret
= nlopt_set_default_initial_step(o, x.empty() ? NULL : &x[0]);
mythrow(ret);
}
void get_initial_step(const std::vector<double> &x, std::vector<double> &dx) const {
if (o && (nlopt_get_dimension(o) != x.size()
|| nlopt_get_dimension(o) != dx.size()))
throw std::invalid_argument("dimension mismatch");
nlopt_result ret = nlopt_get_initial_step(o, x.empty() ? NULL : &x[0],
dx.empty() ? NULL : &dx[0]);
mythrow(ret);
}
std::vector<double> get_initial_step_(const std::vector<double> &x) const {
if (!o) throw std::runtime_error("uninitialized nlopt::opt");
std::vector<double> v(nlopt_get_dimension(o));
get_initial_step(x, v);
return v;
}
};
#undef NLOPT_GETSET
#undef NLOPT_GETSET_VEC
//////////////////////////////////////////////////////////////////////
inline void srand(unsigned long seed) { nlopt_srand(seed); }
inline void srand_time() { nlopt_srand_time(); }
inline void version(int &major, int &minor, int &bugfix) {
nlopt_version(&major, &minor, &bugfix);
}
inline int version_major() {
int major, minor, bugfix;
nlopt_version(&major, &minor, &bugfix);
return major;
}
inline int version_minor() {
int major, minor, bugfix;
nlopt_version(&major, &minor, &bugfix);
return minor;
}
inline int version_bugfix() {
int major, minor, bugfix;
nlopt_version(&major, &minor, &bugfix);
return bugfix;
}
inline const char *algorithm_name(algorithm a) {
return nlopt_algorithm_name(nlopt_algorithm(a));
}
//////////////////////////////////////////////////////////////////////
} // namespace nlopt
#endif /* NLOPT_HPP */