Hello everyone, 

I have been trying to resolve with ISRES the benchmark g11 of the paper 
(Runarsson,Yao) that originated that algorithm. For this benchmark, the 
authors declare they have solved the problem within a couple of hundreds of 
iterations, and they nail the result with high precision. 

This is a 2d problem with equality constraints. I have set the tolerance 
both on the constraint and the stopping criterion to e^-6, which seems 
reasonable considering the bounds of the domain and the value of the 
objective function.

To start with, I have set the intial guess to the solution, with 2% 
perturbation on x1. The algorithm never reaches convergence, but it loops 
until maxEvals is exceeded, no matter the value of maxEvals. 
Note that the solution I get is not far from the correct solution.  

I am surprised that the value of the objective function I get with some 
cout in the objective function leads to an almost caothic plot. 

NLOpt will only find a solution within a finite number of iteration if the 
tolerance is set to --at least-- e^-1.  In this case, the variability of 
the results run after run is pretty high. 

Below, the .cpp file of the C++ code I am running, is there anything wrong 
in what I am doing?



Thanks, 
             Daniele


========

// number of iterations required for this run
int optIterations = 0;

// Set the objective function for tutorial g11


double Optimizer::myfunc_g11(unsigned n, const double *x, double *grad, 
void *my_func_data) {

    // Increment the number of iterations for each call of the objective 
function
    ++optIterations;

    // f(x) = (x1)^2 + ( x2 - 1 )^2
    double f= ( x[0]*x[0] + (x[1]-1)*(x[1]-1) );
    std::cout<<f<<std::endl;
    return f;
}

// Set the constraint function for benchmark g11:
double Optimizer::myconstraint_g11(unsigned n, const double *x, double 
*grad, void *data) {

    //    h(x)= x2 - (x1)^2 = 0
    return x[1] - x[0] * x[0];
}

void Optimizer::run_g11() {

    // Benchmark case 11:
    // f(x) = (x1)^2 + ( x2 - 1 )^2
    // Subjected to :
    //    h(x)= x2 - (x1)^2 = 0

    //where −1 ≤ x1 ≤ 1 and −1 ≤ x2 ≤ 1
    //The optimum solution is
    // x = (±1/sqrt(2),1/2) where f(x) = 0.75

    // Set the dimension of this problem (result vector size)
    size_t dimension=2;

    // Instantiate a NLOpobject and set the ISRES "Improved Stochastic 
Ranking Evolution Strategy"
    // algorithm for nonlinearly-constrained global optimization
    ///GN_ISRES
    nlopt::opt opt(nlopt::GN_ISRES,dimension);

     // Set the and apply the lower and the upper bounds



      std::vector<double> lb(dimension),ub(dimension);
      lb[0] = -1;
      ub[0] = 1;
      lb[1] = -1;
      ub[1] = 1;

   // Set the bounds for the constraints
   opt.set_lower_bounds(lb);
   opt.set_upper_bounds(ub);

   // Set the objective function to be minimized (or maximized, using 
set_max_objective)
   opt.set_min_objective(myfunc_g11, NULL);

   // Set the constraint equations
   opt.add_equality_constraint(myconstraint_g11, NULL, 1e-1);

   // Set the relative tolerance
   opt.set_xtol_rel(1e-1);

   // Set the max number of evaluations and the initial population
   opt.set_maxeval(5000);
   opt.set_population(1000);

   // Set some initial guess. Make sure it is within the
   // bounds that have been set
   std::vector<double> xp(dimension);
   xp[0]= 1./sqrt(2);
   xp[1]= .51;

   std::vector<double> dx(dimension);
   opt.get_initial_step(xp, dx);
   for(size_t i=0; i<dx.size(); i++){
       std::cout<<"dx["<<i<<"]= "<<dx[i]<<std::endl;
   }

   // Launch the optimization; negative retVal implies failure
   double minf;
   nlopt::result result = opt.optimize(xp, minf);

   if (result < 0) {
       printf("nlopt failed!\n");
   }
   else {
           printf("found minimum after %d evaluations\n", optIterations);
           printf("found minimum at f(%g,%g) = %0.10g\n",
               xp[0],xp[1],minf);
   }


}
_______________________________________________
NLopt-discuss mailing list
NLopt-discuss@ab-initio.mit.edu
http://ab-initio.mit.edu/cgi-bin/mailman/listinfo/nlopt-discuss

Reply via email to