nlopt_solver.h

Go to the documentation of this file.

//#include "eus_function.cpp"
#include <sstream>
#include "my_param.h"
 
class NLoptSolver
{
public:
        NLoptSolver(double* x,
                        const double* x_min,
                        const double* x_max,
                        int (*f)(double*,double*), int (*df)(double*,double*),
                        int (*g)(double*,double*), int (*dg)(double*,double*),
                        int (*h)(double*,double*), int (*dh)(double*,double*),
                        int m_x, int m_g, int m_h,
                        double ftol, double xtol, double eqthre, int max_eval, double max_time,
                        Optimization::NLopt::Algorithm algorithm);
        ~NLoptSolver();
        int Optimize();
        double ObjectiveFunctionCost();
 
        void EqualityConstraintCost(double* g);
 
        void InequalityConstraintCost(double* h);
        //
        double *fbuf, *gbuf, *hbuf, *dfbuf, *dgbuf, *dhbuf, *x ;
        //
        //
        // util functions vv
        static void my_log(std::string comment) {
                std::cout << comment << std::endl ;
        }
 
        static void my_log(std::string comment, double val){
                std::ostringstream os;
                os << comment ;
                os << " " << val;
                std::cout << os.str() << std::endl ;
        }
 
        static void my_log(std::string comment, double* val, uint cnt){
                std::ostringstream os;
                os << comment ;
                if ( val && cnt > 0 ){
                        for ( uint i=0; i<cnt ; i++ ){
                                os << " " << val[i] ;
                        }
                }
                std::cout << os.str() << std::endl ;
        }
 
        static void my_copy(double* in, double* out, int size){
                for ( uint i=0 ; i<size ; i++ ){
                        out[i] = in[i] ;
                }
        }
 
        void output_result(int result){
                if(result == NLOPT_SUCCESS)
                {
                        my_log("Succeed.");
                }
                else if(result == NLOPT_FTOL_REACHED)
                {
                        my_log("Succeed: Relative tolerance on function value was reached. ");
                }
                else if(result == NLOPT_XTOL_REACHED)
                {
                        my_log("Succeed: Relative tolerance on optimization parameters was reached. ");
                }
                else if(result == NLOPT_MAXEVAL_REACHED)
                {
                        my_log("Succeed: Maximum number of function evaluations was reached. ");
                }
                else if(result == NLOPT_MAXTIME_REACHED)
                {
                        my_log("Succeed: Maximum optimization time was reached. ");
                }
                else if(result == NLOPT_FAILURE)
                {
                        my_log("Fail.");
                }
                else if(result == NLOPT_INVALID_ARGS)
                {
                        my_log("Fail: Invalid arguments.");
                }
                else if(result == NLOPT_OUT_OF_MEMORY)
                {
                        my_log("Fail: Run out of memory.");
                }
                else if(result == NLOPT_ROUNDOFF_LIMITED)
                {
                        my_log("Fail: Roundoff errors limited progress.");
                }
 
                //
                // if ( this->f ) (*(this->f))(this->x,fbuf) ;
                // if ( this->g ) (*(this->g))(this->x,gbuf) ;
                // if ( this->h ) (*(this->h))(this->x,hbuf) ;
                //
                my_log("Number of iteration.:   ", this->iteration - 1);
                this->ObjectiveFunctionCost();
                my_log("object function: ", this->fbuf[0]) ;
                my_log("  | where     x: ", this->x, this->m_x) ;
                this->EqualityConstraintCost(this->gbuf) ;
                my_log("  |   eq constt: ", this->gbuf, this->m_g) ;
                this->InequalityConstraintCost(this->hbuf) ;
                my_log("  |  neq constt: ", this->hbuf, this->m_h) ;
        }
 
        void stop(){
                nlopt_force_stop(this->solver) ;
        }
 
private:
                nlopt_opt solver;
                nlopt_opt core_solver;
                // double* x;
                int (*f)(double*,double*), (*df)(double*,double*);
                int (*g)(double*,double*), (*dg)(double*,double*);
                int (*h)(double*,double*), (*dh)(double*,double*);
                unsigned int m_x ;
                unsigned int m_g;
                unsigned int m_h;
                unsigned int frequency;
                unsigned int iteration;
                unsigned int n_f;
                unsigned int n_df;
                unsigned int n_g;
                unsigned int n_dg;
                unsigned int n_h;
                unsigned int n_dh;
 
                static double ObjectiveFunctionWrapper(unsigned int n, const double* x, double* df, void* self);
 
                void ObjectiveFunctionGradient(double* df);
 
                static void EqualityConstraintWrapper(unsigned int m, double* g, unsigned int n, const double* x, double* dg, void* self);
 
                void EqualityConstraintGradient(double* dg);
 
                static void InequalityConstraintWrapper(unsigned int m, double* h, unsigned int n, const double* x, double* dh, void* self);
 
                void InequalityConstraintGradient(double* dh);
 
};