int
test_f(const char * desc, gsl_multimin_function *f, initpt_function initpt,
const gsl_multimin_fminimizer_type *T)
{
int status;
size_t i, iter = 0;
gsl_vector *x = gsl_vector_alloc (f->n);
gsl_vector *step_size = gsl_vector_alloc (f->n);
gsl_multimin_fminimizer *s;
fcount = 0; gcount = 0;
(*initpt) (x);
for (i = 0; i < f->n; i++)
gsl_vector_set (step_size, i, 1);
s = gsl_multimin_fminimizer_alloc(T, f->n);
gsl_multimin_fminimizer_set (s, f, x, step_size);
#ifdef DEBUG
printf("x "); gsl_vector_fprintf (stdout, s->x, "%g");
#endif
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
#ifdef DEBUG
printf("%i: \n",iter);
printf("x "); gsl_vector_fprintf (stdout, s->x, "%g");
printf("f(x) %g\n", gsl_multimin_fminimizer_minimum (s));
printf("size: %g\n", gsl_multimin_fminimizer_size (s));
printf("\n");
#endif
status = gsl_multimin_test_size (gsl_multimin_fminimizer_size (s),
1e-3);
}
while (iter < 5000 && status == GSL_CONTINUE);
status |= (fabs(s->fval) > 1e-5);
gsl_test(status, "%s, on %s: %d iter (fn=%d), f(x)=%g",
gsl_multimin_fminimizer_name(s),desc, iter, fcount, s->fval);
gsl_multimin_fminimizer_free(s);
gsl_vector_free(x);
gsl_vector_free(step_size);
return status;
}
static VALUE rb_gsl_fminimizer_name(VALUE obj)
{
gsl_multimin_fminimizer *gmf = NULL;
Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf);
return rb_str_new2(gsl_multimin_fminimizer_name(gmf));
}
extern real fitGemRecomb(double *ct, double *time, double **ctFit,
const int nData, t_gemParams *params)
{
int nThreads, i, iter, status, maxiter;
real size, d2, tol, *dumpdata;
size_t p, n;
gemFitData *GD;
char *dumpstr, dumpname[128];
/* nmsimplex2 had convergence problems prior to gsl v1.14,
* but it's O(N) instead of O(N) operations, so let's use it if v >= 1.14 */
#ifdef HAVE_LIBGSL
gsl_multimin_fminimizer *s;
gsl_vector *x,*dx; /* parameters and initial step size */
gsl_multimin_function fitFunc;
#ifdef GSL_MAJOR_VERSION
#ifdef GSL_MINOR_VERSION
#if ((GSL_MAJOR_VERSION == 1 && GSL_MINOR_VERSION >= 14) || \
(GSL_MAJOR_VERSION > 1))
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2;
#else
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
#endif /* #if ... */
#endif /* GSL_MINOR_VERSION */
#else
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
#endif /* GSL_MAJOR_VERSION */
fprintf(stdout, "Will fit ka and kd to the ACF according to the reversible geminate recombination model.\n");
#else /* HAVE_LIBGSL */
fprintf(stderr, "Sorry, can't do reversible geminate recombination without gsl. "
"Recompile using --with-gsl.\n");
return -1;
#endif /* HAVE_LIBGSL */
#ifdef HAVE_LIBGSL
#ifdef HAVE_OPENMP
nThreads = omp_get_num_procs();
omp_set_num_threads(nThreads);
fprintf(stdout, "We will be using %i threads.\n", nThreads);
#endif
iter = 0;
status = 0;
maxiter = 100;
tol = 1e-10;
p = 2; /* Number of parameters to fit. ka and kd. */
n = params->nFitPoints; /* params->nLin*2 */; /* Number of points in the reduced dataset */
if (params->D <= 0)
{
fprintf(stderr, "Fitting of D is not implemented yet. It must be provided on the command line.\n");
return -1;
}
/* if (nData<n) { */
/* fprintf(stderr, "Reduced data set larger than the complete data set!\n"); */
/* n=nData; */
/* } */
snew(dumpdata, nData);
snew(GD,1);
GD->n = n;
GD->y = ct;
GD->ctTheory=NULL;
snew(GD->ctTheory, nData);
GD->LinLog=NULL;
snew(GD->LinLog, n);
GD->time = time;
GD->ka = 0;
GD->kd = 0;
GD->tDelta = time[1]-time[0];
GD->nData = nData;
GD->params = params;
snew(GD->logtime,params->nFitPoints);
snew(GD->doubleLogTime,params->nFitPoints);
for (i=0; i<params->nFitPoints; i++)
{
GD->doubleLogTime[i] = (double)(getLogIndex(i, params));
GD->logtime[i] = (int)(GD->doubleLogTime[i]);
GD->doubleLogTime[i]*=GD->tDelta;
if (GD->logtime[i] >= nData)
{
fprintf(stderr, "Ayay. It seems we're indexing out of bounds.\n");
params->nFitPoints = i;
}
}
fitFunc.f = &gemFunc_residual2;
fitFunc.n = 2;
fitFunc.params = (void*)GD;
x = gsl_vector_alloc (fitFunc.n);
dx = gsl_vector_alloc (fitFunc.n);
gsl_vector_set (x, 0, 25);
gsl_vector_set (x, 1, 0.5);
gsl_vector_set (dx, 0, 0.1);
gsl_vector_set (dx, 1, 0.01);
s = gsl_multimin_fminimizer_alloc (T, fitFunc.n);
gsl_multimin_fminimizer_set (s, &fitFunc, x, dx);
gsl_vector_free (x);
gsl_vector_free (dx);
do {
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status != 0)
gmx_fatal(FARGS,"Something went wrong in the iteration in minimizer %s:\n \"%s\"\n",
gsl_multimin_fminimizer_name(s), gsl_strerror(status));
d2 = gsl_multimin_fminimizer_minimum(s);
size = gsl_multimin_fminimizer_size(s);
params->ka = gsl_vector_get (s->x, 0);
params->kd = gsl_vector_get (s->x, 1);
if (status)
{
fprintf(stderr, "%s\n", gsl_strerror(status));
break;
}
status = gsl_multimin_test_size(size,tol);
if (status == GSL_SUCCESS) {
fprintf(stdout, "Converged to minimum at\n");
}
printf ("iter %5d: ka = %2.5f kd = %2.5f f() = %7.3f size = %.3f chi2 = %2.5f\n",
iter,
params->ka,
params->kd,
s->fval, size, d2);
if (iter%1 == 0)
{
eq10v2(GD->ctTheory, time, nData, params->ka, params->kd, params);
/* fixGemACF(GD->ctTheory, nFitPoints); */
sprintf(dumpname, "Iter_%i.xvg", iter);
for(i=0; i<GD->nData; i++)
{
dumpdata[i] = (real)(GD->ctTheory[i]);
if (!gmx_isfinite(dumpdata[i]))
{
gmx_fatal(FARGS, "Non-finite value in acf.");
}
}
dumpN(dumpdata, GD->nData, dumpname);
}
}
while ((status == GSL_CONTINUE) && (iter < maxiter));
/* /\* Calculate the theoretical ACF from the parameters one last time. *\/ */
eq10v2(GD->ctTheory, time, nData, params->ka, params->kd, params);
*ctFit = GD->ctTheory;
sfree(GD);
gsl_multimin_fminimizer_free (s);
return d2;
#endif /* HAVE_LIBGSL */
}
static void optimize_remd_parameters(t_remd_data *d, int maxiter,
real tol)
{
real size, d2;
int iter = 0;
int status = 0;
int i;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_vector *x, *dx;
gsl_multimin_function my_func;
my_func.f = &my_f;
my_func.n = d->nparams;
my_func.params = (void *) d;
/* Starting point */
x = gsl_vector_alloc (my_func.n);
for (i = 0; (i < my_func.n); i++)
{
gsl_vector_set (x, i, d->params[i]);
}
/* Step size, different for each of the parameters */
dx = gsl_vector_alloc (my_func.n);
for (i = 0; (i < my_func.n); i++)
{
gsl_vector_set (dx, i, 0.1*d->params[i]);
}
T = gsl_multimin_fminimizer_nmsimplex;
s = gsl_multimin_fminimizer_alloc (T, my_func.n);
gsl_multimin_fminimizer_set (s, &my_func, x, dx);
gsl_vector_free (x);
gsl_vector_free (dx);
printf ("%5s", "Iter");
for (i = 0; (i < my_func.n); i++)
{
printf(" %12s", epnm(my_func.n, i));
}
printf (" %12s %12s\n", "NM Size", "Chi2");
do
{
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status != 0)
{
gmx_fatal(FARGS, "Something went wrong in the iteration in minimizer %s",
gsl_multimin_fminimizer_name(s));
}
d2 = gsl_multimin_fminimizer_minimum(s);
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, tol);
if (status == GSL_SUCCESS)
{
printf ("Minimum found using %s at:\n",
gsl_multimin_fminimizer_name(s));
}
printf ("%5d", iter);
for (i = 0; (i < my_func.n); i++)
{
printf(" %12.4e", gsl_vector_get (s->x, i));
}
printf (" %12.4e %12.4e\n", size, d2);
}
while ((status == GSL_CONTINUE) && (iter < maxiter));
gsl_multimin_fminimizer_free (s);
}
int lua_multimin_minimize(lua_State * L) {
bool ssdel=false;
double eps=0.00001;
double tol=0.0001;
double step_size=0.01;
int maxiter=1000;
bool print=false;
array<double> * x=0;
array<double> * ss=0;
const gsl_multimin_fminimizer_type *Tf = 0;
const gsl_multimin_fdfminimizer_type *Tdf = 0;
multi_param mp;
mp.L=L;
mp.fdf_index=-1;
lua_pushstring(L,"f");
lua_gettable(L,-2);
if(lua_isfunction(L,-1)) {
mp.f_index=luaL_ref(L, LUA_REGISTRYINDEX);
} else {
luaL_error(L,"%s\n","missing function");
}
lua_pushstring(L,"df");
lua_gettable(L,-2);
if(lua_isfunction(L,-1)) {
mp.df_index=luaL_ref(L, LUA_REGISTRYINDEX);
Tdf= gsl_multimin_fdfminimizer_conjugate_fr;
} else {
lua_pop(L,1);
Tf= gsl_multimin_fminimizer_nmsimplex2;
}
lua_pushstring(L,"fdf");
lua_gettable(L,-2);
if(lua_isfunction(L,-1)) {
mp.fdf_index=luaL_ref(L, LUA_REGISTRYINDEX);
} else {
lua_pop(L,1);
mp.fdf_index=-1;
}
lua_pushstring(L,"algorithm");
lua_gettable(L,-2);
if(lua_isstring(L,-1)) {
if(Tf!=0) {
if(!strcmp(lua_tostring(L,-1),"nmsimplex")) {
Tf = gsl_multimin_fminimizer_nmsimplex;
} else if(!strcmp(lua_tostring(L,-1),"nmsimplex2rand")) {
Tf = gsl_multimin_fminimizer_nmsimplex2rand;
} else if(!strcmp(lua_tostring(L,-1),"nmsimplex2")) {
Tf = gsl_multimin_fminimizer_nmsimplex2;
} else {
luaL_error(L,"%s\n","invalid algorithm");
}
} else {
if(!strcmp(lua_tostring(L,-1),"conjugate_pr")) {
Tdf = gsl_multimin_fdfminimizer_conjugate_pr;
} else if(!strcmp(lua_tostring(L,-1),"steepest_descent")) {
Tdf = gsl_multimin_fdfminimizer_steepest_descent;
} else if(!strcmp(lua_tostring(L,-1),"vector_bfgs")) {
Tdf = gsl_multimin_fdfminimizer_vector_bfgs;
} else if(!strcmp(lua_tostring(L,-1),"vector_bfgs2")) {
Tdf = gsl_multimin_fdfminimizer_vector_bfgs2;
} else if(!strcmp(lua_tostring(L,-1),"conjugate_fr")) {
Tdf = gsl_multimin_fdfminimizer_conjugate_fr;
} else {
luaL_error(L,"%s\n","invalid algorithm");
}
}
}
lua_pop(L,1);
lua_pushstring(L,"show_iterations");
lua_gettable(L,-2);
if(lua_isboolean(L,-1)) {
print=(lua_toboolean(L,-1)==1);
}
lua_pop(L,1);
lua_pushstring(L,"eps");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
eps=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"step_size");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
step_size=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"tol");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
tol=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"maxiter");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
maxiter=(int)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"starting_point");
lua_gettable(L,-2);
if(!lua_isuserdata(L,-1)) lua_error(L);
if (!SWIG_IsOK(SWIG_ConvertPtr(L,-1,(void**)&x,SWIGTYPE_p_arrayT_double_t,0))){
luaL_error(L,"%s\n","missing starting point");
}
lua_pop(L,1);
if(Tf) {
lua_pushstring(L,"step_sizes");
lua_gettable(L,-2);
if(lua_isuserdata(L,-1)) {
if (!SWIG_IsOK(SWIG_ConvertPtr(L,-1,(void**)&ss,SWIGTYPE_p_arrayT_double_t,0))){
lua_error(L);
}
} else {
ssdel=true;
ss=new array<double>(x->size());
ss->set_all(1.0);
if(lua_isnumber(L,-1)) {
double v=lua_tonumber(L,-1);
ss->set_all(v);
}
}
lua_pop(L,1);
}
lua_pop(L,1);
if(Tf) {
gsl_multimin_fminimizer *s = NULL;
gsl_vector SS, X;
gsl_multimin_function minex_func;
int iter = 0;
int status;
double size;
int N=x->size();
/* Starting point */
X.size=x->size();
X.stride=1;
X.data=x->data();
X.owner=0;
/* Set initial step sizes */
SS.size=ss->size();
SS.stride=1;
SS.data=ss->data();
SS.owner=0;
/* Initialize method and iterate */
minex_func.n = N;
minex_func.f = multimin_f_cb;
minex_func.params = ∓
s = gsl_multimin_fminimizer_alloc (Tf, N);
gsl_multimin_fminimizer_set (s, &minex_func, &X, &SS);
if(print) printf ("running algorithm '%s'\n",
gsl_multimin_fminimizer_name (s));
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (size, eps);
if (status == GSL_SUCCESS)
{
if(print) printf ("converged to minimum at\n");
}
if(print) printf ("%5d f() = %12.3f size = %.9f\n",
iter,
s->fval, size);
} while (status == GSL_CONTINUE && iter < maxiter);
for(int i=0;i<N;++i) x->set(i,gsl_vector_get(s->x,i));
luaL_unref(L, LUA_REGISTRYINDEX, mp.f_index);
gsl_multimin_fminimizer_free (s);
} else {
gsl_multimin_fdfminimizer *s = NULL;
gsl_vector X;
gsl_multimin_function_fdf minex_func;
int iter = 0;
int status;
double size;
int N=x->size();
/* Starting point */
X.size=x->size();
X.stride=1;
X.data=x->data();
X.owner=0;
/* Initialize method and iterate */
minex_func.n = N;
minex_func.f = multimin_f_cb;
minex_func.df = multimin_df_cb;
minex_func.fdf = multimin_fdf_cb;
minex_func.params = ∓
s = gsl_multimin_fdfminimizer_alloc (Tdf, N);
gsl_multimin_fdfminimizer_set (s, &minex_func, &X, step_size, tol);
if(print) printf ("running algorithm '%s'\n",
gsl_multimin_fdfminimizer_name (s));
do
{
iter++;
status = gsl_multimin_fdfminimizer_iterate(s);
if (status)
break;
status = gsl_multimin_test_gradient (s->gradient, eps);
if (status == GSL_SUCCESS)
{
if(print) printf ("converged to minimum at\n");
}
if(print) printf ("%5d f() = %12.3f\n",
iter,
s->f);
} while (status == GSL_CONTINUE && iter < maxiter);
for(int i=0;i<N;++i) x->set(i,gsl_vector_get(s->x,i));
luaL_unref(L, LUA_REGISTRYINDEX, mp.f_index);
luaL_unref(L, LUA_REGISTRYINDEX, mp.df_index);
gsl_multimin_fdfminimizer_free (s);
}
if(mp.fdf_index>=0) {
luaL_unref(L, LUA_REGISTRYINDEX, mp.fdf_index);
}
if(ssdel) {
delete ss;
}
return 0;
}
