double * optimize(double(*pFun)(double const *), int nrestarts, double incpopsize, char * filename) { cmaes_t evo; /* the optimizer */ double *const*pop; /* sampled population */ double *fitvals; /* objective function values of sampled population */ double fbestever=0, *xbestever=NULL; /* store best solution */ double fmean; int i, irun, lambda = 0, /* offspring population size, 0 invokes default */ countevals = 0; /* used to set for restarts */ char const * stop; /* stop message */ for (irun = 0; irun < nrestarts+1; ++irun) /* restarts */ { /* Parameters can be set in three ways. Here as input parameter * to cmaes_init, as value read from cmaes_initials.par in readpara_init * during initialization, and as value read from cmaes_signals.par by * calling cmaes_ReadSignals explicitely. */ fitvals = cmaes_init(&evo, 0, NULL, NULL, 0, lambda, filename); /* allocs fitvals */ printf("%s\n", cmaes_SayHello(&evo)); evo.countevals = countevals; /* a hack, effects the output and termination */ cmaes_ReadSignals(&evo, "cmaes_signals.par"); /* write initial values, headers in case */ while(!(stop=cmaes_TestForTermination(&evo))) { /* Generate population of new candidate solutions */ pop = cmaes_SamplePopulation(&evo); /* do not change content of pop */ /* Here optionally handle constraints etc. on pop. You may * call cmaes_ReSampleSingle(&evo, i) to resample the i-th * vector pop[i], see below. Do not change pop in any other * way. You may also copy and modify (repair) pop[i] only * for the evaluation of the fitness function and consider * adding a penalty depending on the size of the * modification. */ /* Compute fitness value for each candidate solution */ for (i = 0; i < cmaes_Get(&evo, "popsize"); ++i) { /* We may resample the solution i until it lies within the feasible domain here. The function is_feasible() needs to be user-defined. Assumptions: the feasible domain is convex, the optimum is not on (or very close to) the domain boundary, initialX is feasible (or in case typicalX +- 2*initialStandardDeviations is feasible) and initialStandardDeviations is (are) sufficiently small to prevent quasi-infinite looping. */ /* while (!is_feasible(pop[i])) cmaes_ReSampleSingle(&evo, i); */ fitvals[i] = (*pFun)(pop[i]); } /* update search distribution */ cmaes_UpdateDistribution(&evo, fitvals); /* read control signals for output and termination */ cmaes_ReadSignals(&evo, "cmaes_signals.par"); /* from file cmaes_signals.par */ fflush(stdout); } /* while !cmaes_TestForTermination(&evo) */ lambda = incpopsize * cmaes_Get(&evo, "lambda"); /* needed for the restart */ countevals = cmaes_Get(&evo, "eval"); /* ditto */ /* print some "final" output */ printf("%.0f generations, %.0f fevals (%.1f sec): f(x)=%g\n", cmaes_Get(&evo, "gen"), cmaes_Get(&evo, "eval"), evo.eigenTimings.totaltime, cmaes_Get(&evo, "funval")); printf(" (axis-ratio=%.2e, max/min-stddev=%.2e/%.2e)\n", cmaes_Get(&evo, "maxaxislen") / cmaes_Get(&evo, "minaxislen"), cmaes_Get(&evo, "maxstddev"), cmaes_Get(&evo, "minstddev") ); printf("Stop (run %d):\n%s\n", irun+1, cmaes_TestForTermination(&evo)); /* write some data */ cmaes_WriteToFile(&evo, "all", "allcmaes.dat"); /* keep best ever solution */ if (irun == 0 || cmaes_Get(&evo, "fbestever") < fbestever) { fbestever = cmaes_Get(&evo, "fbestever"); xbestever = cmaes_GetInto(&evo, "xbestever", xbestever); /* alloc mem if needed */ } /* best estimator for the optimum is xmean, therefore check */ if ((fmean = (*pFun)(cmaes_GetPtr(&evo, "xmean"))) < fbestever) { fbestever = fmean; xbestever = cmaes_GetInto(&evo, "xmean", xbestever); } cmaes_exit(&evo); /* does not effect the content of stop string and xbestever */ /* abandon restarts if target fitness value was achieved or MaxFunEvals reached */ if (stop) /* as it can be NULL */ { if (strncmp(stop, "Fitness", 7) == 0 || strncmp(stop, "MaxFunEvals", 11) == 0) break; } if (strncmp(stop, "Manual", 6) == 0) { printf("Press RETURN to start next run\n"); fflush(stdout); getchar(); } } /* for restarts */ return xbestever; /* was dynamically allocated, should be freed in the end */ }
/* the optimization loop */ int main(int argn, char **args) { cmaes_t evo; /* an CMA-ES type struct or "object" */ boundary_transformation_t boundaries; double *arFunvals, *x_in_bounds, *const*pop; double lowerBounds[] = {1.0, DBL_MAX / -1e2}; /* last number is recycled for all remaining coordinates */ double upperBounds[] = {3, 2e22}; int nb_bounds = 1; /* numbers used from lower and upperBounds */ unsigned long dimension; int i; /* initialize boundaries, be sure that initialSigma is smaller than upper minus lower bound */ boundary_transformation_init(&boundaries, lowerBounds, upperBounds, nb_bounds); /* Initialize everything into the struct evo, 0 means default */ arFunvals = cmaes_init(&evo, 0, NULL, NULL, 0, 0, "cmaes_initials.par"); dimension = (unsigned long)cmaes_Get(&evo, "dimension"); printf("%s\n", cmaes_SayHello(&evo)); x_in_bounds = cmaes_NewDouble(dimension); /* calloc another vector */ cmaes_ReadSignals(&evo, "cmaes_signals.par"); /* write header and initial values */ /* Iterate until stop criterion holds */ while(!cmaes_TestForTermination(&evo)) { /* generate lambda new search points, sample population */ pop = cmaes_SamplePopulation(&evo); /* do not change content of pop */ /* transform into bounds and evaluate the new search points */ for (i = 0; i < cmaes_Get(&evo, "lambda"); ++i) { boundary_transformation(&boundaries, pop[i], x_in_bounds, dimension); /* this loop can be omitted if is_feasible is invariably true */ while(!is_feasible(x_in_bounds, dimension)) { /* is_feasible needs to be user-defined, in case, and can change/repair x */ cmaes_ReSampleSingle(&evo, i); boundary_transformation(&boundaries, pop[i], x_in_bounds, dimension); } arFunvals[i] = fitfun(x_in_bounds, dimension); /* evaluate */ } /* update the search distribution used for cmaes_SampleDistribution() */ cmaes_UpdateDistribution(&evo, arFunvals); /* assumes that pop[i] has not been modified */ /* read instructions for printing output or changing termination conditions */ cmaes_ReadSignals(&evo, "cmaes_signals.par"); fflush(stdout); /* useful in MinGW */ } printf("Stop:\n%s\n", cmaes_TestForTermination(&evo)); /* print termination reason */ cmaes_WriteToFile(&evo, "all", "allcmaes.dat"); /* write final results */ /* get best estimator for the optimum, xmean */ boundary_transformation(&boundaries, (double const *) cmaes_GetPtr(&evo, "xmean"), /* "xbestever" might be used as well */ x_in_bounds, dimension); /* do something with final solution x_in_bounds */ /* ... */ /* and finally release memory */ cmaes_exit(&evo); /* release memory */ boundary_transformation_exit(&boundaries); /* release memory */ free(x_in_bounds); return 0; }