Changeset 5712


Ignore:
Timestamp:
11/03/08 12:40:41 (5 years ago)
Author:
wehart
Message:

Updates for OPT++ wrappers. A QNewton wrapper has been prototypes, but not tested.

Location:
interfaces/trunk
Files:
3 edited
1 moved

Legend:

Unmodified
Added
Removed
  • interfaces/trunk/interfaces/Makefile.am

    r4976 r5712  
    1919MOMHLib.h\ 
    2020NPSOL.h\ 
     21OPTpp.h\ 
    2122TCC.h 
    2223 
  • interfaces/trunk/interfaces/OPTpp.h

    r5709 r5712  
    1414 */ 
    1515 
    16 #ifndef interfaces_Cobyla_h 
    17 #define interfaces_Cobyla_h 
     16#ifndef interfaces_OPTpp_h 
     17#define interfaces_COPTpp_h 
    1818 
    1919#include <acro_config.h> 
    20 #ifdef ACRO_USING_COBYLA 
     20#ifdef ACRO_USING_OPTPP 
    2121 
    2222#include <colin/colin.h> 
     
    2525namespace interfaces { 
    2626 
    27 /** An interface to the COBYLA2 direct search method. 
    28   * 
    29   * This interface uses the utilib::BasicArray class to avoid copying between 
    30   * this C++ and COBYLA's Fortran code. 
     27// Newton UNLP2 
     28// Newton UNLP1 
     29 
     30// NIPS   NLP2 
     31// NIPS   NLP1 
     32 
     33// NLP    NLP2 
     34// NLP    NLP1 
     35 
     36// lbfgs  UNLP1 
     37// cg     UNLP1 
     38// pds    UNLP0 
     39 
     40 
     41 
     42/** A base class for NLP0 optimizers for OPT++ 
    3143  */ 
    32 class Cobyla : public colin::OptSolver<colin::NLP0_problem> 
     44class OptppNLP0 : public colin::OptSolver<colin::NLP0_problem> 
    3345{ 
    3446public: 
    3547 
    3648  /// Constructor 
    37   Cobyla(); 
     49  OptppNLP0(); 
     50 
     51private: 
     52 
     53  /// 
     54  OptppNLP0(const OptppNLP0& ) : nlf(0) {} 
     55 
     56  /// 
     57  ~OptppNLP0(); 
     58 
     59  /// 
     60  OptppNLP0& operator=(const OptppNLP0& ) {return *this;} 
     61 
     62  /// 
     63  void reset_OptppNLP0(); 
     64 
     65protected: 
     66 
     67  /// 
     68  class NLF0; 
     69 
     70  /// 
     71  NLF0* nlf; 
     72 
     73}; 
     74 
     75 
     76/** A base class for NLP1 optimizers for OPT++ 
     77  */ 
     78class OptppNLP1 : public colin::OptSolver<colin::NLP1_problem> 
     79{ 
     80public: 
     81 
     82  /// Constructor 
     83  OptppNLP1(); 
     84 
     85  /// 
     86  ~OptppNLP1(); 
     87 
     88private: 
     89 
     90  /// 
     91  OptppNLP1(const OptppNLP1& ) {} 
     92 
     93  /// 
     94  OptppNLP1& operator=(const OptppNLP1& ) {return *this;} 
     95 
     96  /// 
     97  void reset_OptppNLP1(); 
     98 
     99protected: 
     100 
     101  /// 
     102  class NLF1; 
     103 
     104  /// 
     105  NLF1* nlf; 
     106 
     107}; 
     108 
     109 
     110#if 0 
     111/** A base class for NLP2 optimizers for OPT++ 
     112  */ 
     113class OptppNLP2 : public colin::OptSolver<colin::NLP2_problem> 
     114{ 
     115public: 
     116 
     117  /// Constructor 
     118  OptppNLP2(); 
     119 
     120private: 
     121 
     122  /// 
     123  OptppNLP2(const OptppNLP2& ) {} 
     124 
     125  /// 
     126  OptppNLP2& operator=(const OptppNLP2& ) {return *this;} 
     127 
     128  /// 
     129  class NLF2; 
     130 
     131  /// 
     132  NLF2* nlf; 
     133 
     134  /// 
     135  void reset_OptppNLP2(); 
     136 
     137}; 
     138#endif 
     139 
     140 
     141/** An interface to the OPTpp Newton solver with NLP1 
     142  */ 
     143class OptppQNewton : public OptppNLP1 
     144{ 
     145public: 
     146 
     147  /// Constructor 
     148  OptppQNewton(); 
    38149 
    39150  /// 
    40151  void optimize(); 
    41152 
    42   /// The function used to compute the constraints and objective 
    43   static void calcfc(int n, int m, double* x, double* f, double* con ); 
    44  
    45153protected: 
    46154 
    47155  /// 
    48   std::string derived_solver_type() const 
    49         { return "Cobyla"; } 
    50  
    51   /// 
    52   double step_tolerance; 
    53  
    54   /// 
    55   double initial_step; 
    56  
    57   /// 
    58   int max_neval; 
    59  
    60   /// 
    61   //colin::SimplifiedConstraintInterface<colin::NLP0_problem>* simple_app; 
    62  
    63   /// 
    64   static utilib::BasicArray<double> calcfc_point; 
    65  
    66   /// 
    67   static utilib::BasicArray<colin::real> calcfc_cvec; 
    68  
    69   /// 
    70   static colin::real calcfc_value; 
    71  
    72   /// 
    73   static utilib::BasicArray<colin::real> clower; 
    74  
    75   /// 
    76   static utilib::BasicArray<colin::real> cupper; 
    77  
    78   /// 
    79   static utilib::BasicArray<colin::real> blower; 
    80  
    81   /// 
    82   static utilib::BasicArray<colin::real> bupper; 
    83  
    84   /// 
    85   static colin::OptProblem<colin::NLP0_problem>* calcfc_problem; 
    86  
    87   /// TODO: why do we need this? 
    88   static colin::EvaluationManager static_eval_mngr; 
     156  std::string define_solver_type() const 
     157        { return "optpp:qnewton"; } 
    89158 
    90159private: 
    91160 
    92161  /// 
    93   void reset_Cobyla(); 
     162  void reset_OptppQNewton(); 
    94163 
    95164}; 
  • interfaces/trunk/src/Makefile.am

    r5708 r5712  
    2727AM_CPPFLAGS=-I$(top_builddir) -I$(top_srcdir)/config \ 
    2828            -I$(TOPINC) -I$(TOPINC)/appspack -I$(TOPINC)/3po \ 
     29            -I$(top_srcdir)/packages/optpp/include \ 
     30            -I$(top_srcdir)/packages/optpp/newmat11 \ 
    2931            -I$(TOPINC)/tinyxml -I$(TOPINC)/ampl -I$(TOPINC)/momhlib\ 
    3032                -DMPICH_IGNORE_CXX_SEEK 
    3133 
    3234libinterfaces_a_SOURCES= \ 
    33 lib/Cobyla.cpp\ 
    34 lib/Hooke.cpp 
     35lib/OPTpp.cpp 
    3536 
    3637FOO= \ 
  • interfaces/trunk/src/lib/OPTpp.cpp

    r5272 r5712  
    99 
    1010// 
    11 // OPTPP.cpp 
     11// OPTpp.cpp 
    1212// 
    1313 
    1414#include <acro_config.h> 
    15 #ifdef ACRO_USING_OPTPP 
    16  
    17 #include <interfaces/Factory.h> 
     15#ifdef ACRO_USING_COBYLA 
     16 
     17#include <OptBCQNewton.h> 
     18#include <OptQNewton.h> 
     19#include <NLP1.h> 
     20#include <colin/SolverMngr.h> 
    1821#include <interfaces/OPTpp.h> 
    19 #include <colin/ConcreteOptSolverHandle.h> 
    20 #include "OptBaNewton.h" 
    21 #include "OptBaQNewton.h" 
    22 #include "OptBCEllipsoid.h" 
    23 #include "OptBCFDNewton.h" 
    24 #include "OptBCNewton.h" 
    25 #include "OptBCNewtonLike.h" 
    26 #include "OptBCQNewton.h" 
    27 #include "OptCG.h" 
    28 #include "OptConstrFDNewton.h" 
    29 #include "OptConstrNewton.h" 
    30 #include "OptConstrNewtonLike.h" 
    31 #include "OptConstrQNewton.h" 
    32 #include "OptDHNIPS.h" 
    33 #include "OptDirect.h" 
    34 #include "OptFDNewton.h" 
    35 #include "OptFDNIPS.h" 
    36 #include "OptGSS.h" 
    37 #include "Opt.h" 
    38 #include "OptLBFGS.h" 
    39 #include "OptNewton.h" 
    40 #include "OptNewtonLike.h" 
    41 #include "OptNIPS.h" 
    42 #include "OptNIPSLike.h" 
    43 #include "OptNPSOL.h" 
    44 #include "Opt_PARAMS.h" 
    45 #include "OptPDS.h" 
    46 #include "OptppArray.h" 
    47 #include "OptppBool.h" 
    48 #include "OptppExceptions.h" 
    49 #include "OptppFatalError.h" 
    50 #include "OptppSmartPtr.h" 
    51 #include "OptQNewton.h" 
    52 #include "OptQNIPS.h" 
    5322 
    5423using namespace std; 
     24using namespace utilib; 
    5525 
    5626namespace interfaces { 
    5727 
    58 real Cobyla::calcfc_value; 
    59 BasicArray<double> Cobyla::calcfc_point; 
    60 BasicArray<real> Cobyla::calcfc_cvec; 
    61 BasicArray<real> Cobyla::clower; 
    62 BasicArray<real> Cobyla::cupper; 
    63 BasicArray<real> Cobyla::blower; 
    64 BasicArray<real> Cobyla::bupper; 
    65  
    66  
    67 colin::OptProblem<colin::NLP0_problem>* Cobyla::calcfc_problem; 
    68 colin::EvaluationManager Cobyla::static_eval_mngr; 
    69  
    70 extern "C" int calc_func(int n, int m, double* x, double* f, double* con, void* state) 
    71 { Cobyla::calcfc(n,m,x,f,con); return 0; } 
    72  
    73  
    74 void Cobyla::calcfc(int n, int m, double* x, double* f, double* con) 
    75 { 
    76 calcfc_point.set_data(n,((double*)x)); 
    77 (*calcfc_problem)->EvalF(static_eval_mngr, calcfc_point,calcfc_value); 
    78  
    79 *f = calcfc_value; 
    80  
    81 int ndx=0; 
    82 if ((*calcfc_problem)->enforcing_bounds()) { 
    83    for (int i=0; i<n; i++) { 
    84      if (finite(blower[i])) con[ndx++] = -(blower[i] - x[i]); 
    85      if (finite(bupper[i])) con[ndx++] = -(x[i] - bupper[i]); 
    86      } 
    87    } 
    88 if (calcfc_cvec.size() > 0) { 
    89    (*calcfc_problem)->EvalCF(static_eval_mngr, calcfc_point,calcfc_cvec); 
    90    for (size_type i=0; i<calcfc_cvec.size(); i++) { 
    91      if (finite(clower[i])) con[ndx++] = -(clower[i] - calcfc_cvec[i]); 
    92      if (finite(cupper[i])) con[ndx++] = -(calcfc_cvec[i] - cupper[i]); 
    93      } 
    94    } 
    95  
    96 //for (int i=0; i<m; i++) 
    97   //cerr << "CON " << i << " " << con[i] << endl; 
    98 } 
    99  
    100  
    101 Cobyla::Cobyla() 
    102  : step_tolerance(1e-4), 
    103    initial_step(1.0), 
    104    simple_app(0) 
    105 { 
    106 solver_type="Cobyla"; 
    107  
    108 disable_parameter("max_iters"); 
    109 disable_parameter("max_time"); 
    110 disable_parameter("ftol"); 
    111 disable_parameter("constraint_tolerance"); 
    112 disable_parameter("output_frequency"); 
    113 disable_parameter("output_flush"); 
    114 disable_parameter("output_final"); 
    115 disable_parameter("output_dynamic"); 
    116 disable_parameter("debug_opt_stats"); 
    117 disable_parameter("debug_all"); 
    118 disable_parameter("debug_best_point"); 
    119 disable_parameter("debug_num_evaluations"); 
    120 disable_parameter("debug_iteration_info"); 
    121 disable_parameter("debug_best"); 
    122 disable_parameter("debug_time"); 
    123  
    124 create_parameter("step_tolerance",step_tolerance, 
    125         "<double>","1e-4", 
    126         "Convergence tolerance step length"); 
    127 create_parameter("initial_step",initial_step, 
    128         "<double>","1.0", 
    129         "Initial step length"); 
    130 } 
    131  
    132  
    133 void Cobyla::reset() 
    134 { 
    135 if (!problem) 
     28 
     29namespace { 
     30 
     31int lexical_cast_from_newmat(const Any& from, Any& to) 
     32{ 
     33   const NEWMAT::ColumnVector& data = from.expose<NEWMAT::ColumnVector>(); 
     34   vector<double>& ans = to.set<vector<double> >(); 
     35   ans.reserve(data.size()); 
     36   for (size_t i=0; i<data.size(); i++) 
     37     ans.push_back(data(i+1)); 
     38   return OK; 
     39} 
     40 
     41int lexical_cast_to_newmat(const Any& from, Any& to) 
     42{ 
     43   const vector<double>& data = from.expose<vector<double> >(); 
     44   NEWMAT::ColumnVector& ans = to.set<NEWMAT::ColumnVector>(); 
     45   ans.ReSize(data.size()); 
     46   for (size_t i=0; i<data.size(); i++) 
     47     ans(i+1) = data[i]; 
     48   return OK; 
     49} 
     50 
     51bool optpp_lexical_casts() 
     52{ 
     53   colin::ContextMngr().register_lexical_cast 
     54      (typeid(NEWMAT::ColumnVector), 
     55       typeid(std::vector<double>), 
     56       &lexical_cast_from_newmat); 
     57   colin::ContextMngr().register_lexical_cast 
     58      (typeid(std::vector<double>), 
     59       typeid(NEWMAT::ColumnVector), 
     60       &lexical_cast_to_newmat); 
     61} 
     62 
     63bool dummy1 = optpp_lexical_casts(); 
     64 
     65} 
     66 
     67 
     68class OptppNLP0::NLF0 : public OPTPP::NLF0 
     69{ 
     70public: 
     71 
     72    /// 
     73    NLF0() : OPTPP::NLF0() {} 
     74 
     75    /// 
     76    void initFcn(); 
     77 
     78    /// 
     79    colin::OptProblem<colin::UNLP0_problem> problem; 
     80 
     81    /// 
     82    NEWMAT::ColumnVector initial_point; 
     83 
     84    /// 
     85    OPTPP::real evalF(); 
     86 
     87    /// 
     88    double evalF(const NEWMAT::ColumnVector& x); 
     89 
     90    /// 
     91    NEWMAT::ColumnVector evalG() 
     92        { return OPTPP::NLF0::evalG(); } 
     93 
     94    /// 
     95    NEWMAT::ColumnVector evalG(const NEWMAT::ColumnVector& x); 
     96 
     97    /// 
     98    void my_fcn_v(const NEWMAT::ColumnVector& x, double& fvalue, int& result) 
     99        { 
     100        result=OPTPP::NLPFunction; 
     101        colin::AppRequest req = problem->set_domain(x); 
     102        problem->Request_F(req, fvalue); 
     103        colin::AppResponse r1 = problem->eval_mngr().perform_evaluation(req); 
     104        } 
     105}; 
     106 
     107 
     108void OptppNLP0::NLF0::initFcn() // Initialize Function 
     109{ 
     110  if (init_flag == false)  { 
     111    utilib::TypeManager()->lexical_cast(initial_point, mem_xc); 
     112    init_flag = true; 
     113  } 
     114  else  { 
     115    cerr << "NLF0:initFcn: Warning - initialization called twice\n"; 
     116    utilib::TypeManager()->lexical_cast(initial_point, mem_xc); 
     117  } 
     118} 
     119 
     120double OptppNLP0::NLF0::evalF() // Evaluate Function 
     121{ 
     122  int result = 0; 
     123  double time0 = get_wall_clock_time(); 
     124 
     125  if (SpecFlag == OPTPP::NoSpec) { 
     126    if (!application.getF(mem_xc,fvalue)) { 
     127      my_fcn_v(mem_xc, fvalue, result); 
     128      application.update(OPTPP::NLPFunction,dim,mem_xc,fvalue); 
     129      nfevals++; 
     130    } 
     131  } 
     132  else { 
     133    SpecFlag = OPTPP::Spec1; 
     134    (void) evalG(); 
     135    SpecFlag = OPTPP::Spec2; 
     136  } 
     137 
     138  function_time = get_wall_clock_time() - time0; 
     139  return fvalue; 
     140} 
     141 
     142double OptppNLP0::NLF0::evalF(const NEWMAT::ColumnVector& x) // Evaluate Function at x 
     143{ 
     144  double fx; 
     145  int result = 0; 
     146  double time0 = get_wall_clock_time(); 
     147 
     148  if (SpecFlag == OPTPP::NoSpec) { 
     149    if (!application.getF(x,fx)) { 
     150      my_fcn_v(x, fx, result); 
     151      application.update(OPTPP::NLPFunction,dim,x,fx); 
     152      nfevals++; 
     153    } 
     154  } 
     155  else { 
     156    SpecFlag = OPTPP::Spec1; 
     157    (void) evalG(x); 
     158    fx = specF; 
     159    SpecFlag = OPTPP::Spec2; 
     160  } 
     161 
     162  function_time = get_wall_clock_time() - time0; 
     163  return fx; 
     164} 
     165 
     166NEWMAT::ColumnVector OptppNLP0::NLF0::evalG(const NEWMAT::ColumnVector& x) 
     167{ 
     168  NEWMAT::ColumnVector gx(dim); 
     169  NEWMAT::ColumnVector sx(dim); 
     170  sx = 1.0; 
     171 
     172  // Since NLF0 objects do not have analytic gradients supply 
     173  // one by using finite differences 
     174 
     175  if (SpecFlag == OPTPP::NoSpec) { 
     176    int result = 0; 
     177    if (!application.getF(x, specF)) { 
     178      my_fcn_v(x, specF, result); 
     179      nfevals++; 
     180    } 
     181  } 
     182 
     183  gx = FDGrad(sx, x, specF, partial_grad); 
     184  return gx; 
     185} 
     186 
     187 
     188class OptppNLP1::NLF1 : public OPTPP::NLF1 
     189{ 
     190public: 
     191 
     192    /// 
     193    NLF1() : OPTPP::NLF1() {} 
     194 
     195    /// 
     196    void initFcn(); 
     197 
     198    /// 
     199    colin::OptProblem<colin::UNLP1_problem> problem; 
     200 
     201    /// 
     202    NEWMAT::ColumnVector initial_point; 
     203 
     204    /// 
     205    void eval(); 
     206 
     207    /// 
     208    OPTPP::real evalF(); 
     209 
     210    /// 
     211    double evalF(const NEWMAT::ColumnVector& x); 
     212 
     213    /// 
     214    NEWMAT::ColumnVector evalG(); 
     215 
     216    /// 
     217    NEWMAT::ColumnVector evalG(const NEWMAT::ColumnVector& x); 
     218 
     219    /// 
     220    void my_fcn_v(int request, const NEWMAT::ColumnVector& x, double& fvalue, const NEWMAT::ColumnVector& grad, int& result) 
     221        { 
     222        result=request; 
     223        colin::AppRequest req = problem->set_domain(x); 
     224        if (request | OPTPP::NLPFunction) 
     225            problem->Request_F(req, fvalue); 
     226        if (request | OPTPP::NLPGradient) 
     227            problem->Request_G(req, grad); 
     228        colin::AppResponse r1 = problem->eval_mngr().perform_evaluation(req); 
     229        } 
     230}; 
     231 
     232double OptppNLP1::NLF1::evalF() // Evaluate Function 
     233{ 
     234  int result = 0; 
     235  NEWMAT::ColumnVector gtmp(dim); 
     236 
     237  double time0 = get_wall_clock_time(); 
     238  // *** CHANGE *** // 
     239  if (!application.getF(mem_xc,fvalue)) { 
     240    fcn_v(OPTPP::NLPFunction, dim, mem_xc, fvalue, gtmp, result, vptr); 
     241    application.update(result,dim,mem_xc,fvalue,gtmp); 
     242    nfevals++; 
     243  } 
     244  // *** CHANGE *** // 
     245  function_time = get_wall_clock_time() - time0; 
     246 
     247  if (debug_) 
     248  cout << "NLF1::evalF()\n" 
     249    << "nfevals       = " << nfevals << "\n" 
     250    << "fvalue        = " << fvalue << "\n" 
     251    << "function time = " << function_time << "\n"; 
     252  return fvalue; 
     253} 
     254 
     255double OptppNLP1::NLF1::evalF(const NEWMAT::ColumnVector& x) // Evaluate Function at x 
     256{ 
     257  int    result = 0; 
     258  double fx; 
     259  NEWMAT::ColumnVector gtmp(dim); 
     260 
     261  double time0 = get_wall_clock_time(); 
     262  // *** CHANGE *** // 
     263  if (!application.getF(x,fx)) { 
     264    fcn_v(OPTPP::NLPFunction, dim, x, fx, gtmp, result, vptr); 
     265    application.update(result,dim,x,fx,gtmp); 
     266    nfevals++; 
     267  } 
     268  // *** CHANGE *** // 
     269  function_time = get_wall_clock_time() - time0; 
     270 
     271  if (debug_) 
     272  cout << "NLF1::evalF(x)\n" 
     273    << "nfevals       = " << nfevals << "\n" 
     274    << "fvalue        = " << fx << "\n" 
     275    << "function time = " << function_time << "\n"; 
     276  return fx; 
     277} 
     278 
     279NEWMAT::ColumnVector OptppNLP1::NLF1::evalG() // Evaluate the gradient 
     280{ 
     281  int    result = 0; 
     282  double fx; 
     283 
     284  // *** CHANGE *** // 
     285  if (!application.getGrad(mem_xc,mem_grad)) { 
     286    fcn_v(OPTPP::NLPGradient, dim, mem_xc, fx, mem_grad, result, vptr); 
     287    application.update(result,dim,mem_xc,fx,mem_grad); 
     288    ngevals++; 
     289  } 
     290  // *** CHANGE *** // 
     291  return mem_grad; 
     292} 
     293 
     294NEWMAT::ColumnVector OptppNLP1::NLF1::evalG(const NEWMAT::ColumnVector& x) // Evaluate the gradient at x 
     295{ 
     296  int    result = 0 ; 
     297  double fx; 
     298  NEWMAT::ColumnVector gx(dim); 
     299 
     300  // *** CHANGE *** // 
     301  if (!application.getGrad(x,gx)) { 
     302    fcn_v(OPTPP::NLPGradient, dim, x, fx, gx, result, vptr); 
     303    application.update(result,dim,x,fx,gx); 
     304    ngevals++; 
     305  } 
     306  // *** CHANGE *** // 
     307  return gx; 
     308} 
     309 
     310void OptppNLP1::NLF1::eval() // Evaluate Function and Gradient 
     311{ 
     312  int mode = OPTPP::NLPFunction | OPTPP::NLPGradient, result = 0; 
     313 
     314  double time0 = get_wall_clock_time(); 
     315  // *** CHANGE *** // 
     316  if (!application.getF(mem_xc,fvalue) || !application.getGrad(mem_xc,mem_grad)) { 
     317    fcn_v(mode, dim, mem_xc, fvalue, mem_grad, result, vptr); 
     318    application.update(result,dim,mem_xc,fvalue,mem_grad); 
     319    nfevals++; ngevals++; 
     320  } 
     321  // *** CHANGE *** // 
     322 
     323  function_time = get_wall_clock_time() - time0; 
     324 
     325  if (debug_) 
     326  cout << "NLF1::eval()\n" 
     327    << "mode          = " << mode   << "\n" 
     328    << "nfevals       = " << nfevals << "\n" 
     329    << "fvalue        = " << fvalue << "\n" 
     330    << "function time = " << function_time << "\n"; 
     331} 
     332 
     333 
     334 
     335OptppNLP0::OptppNLP0() 
     336{ reset_signal.connect( boost::bind( &OptppNLP0::reset_OptppNLP0, this ) ); } 
     337 
     338OptppNLP0::~OptppNLP0() 
     339{ if (nlf) delete nlf; } 
     340 
     341void OptppNLP0::reset_OptppNLP0() 
     342{ 
     343if (problem.empty()) return; 
     344if (nlf) delete nlf; 
     345nlf = new NLF0; 
     346nlf->problem=problem; 
     347} 
     348 
     349 
     350OptppNLP1::OptppNLP1() 
     351{ reset_signal.connect( boost::bind( &OptppNLP1::reset_OptppNLP1, this ) ); } 
     352 
     353OptppNLP1::~OptppNLP1() 
     354{ if (nlf) delete nlf; } 
     355 
     356void OptppNLP1::reset_OptppNLP1() 
     357{ 
     358if (problem.empty()) return; 
     359if (nlf) delete nlf; 
     360nlf = new NLF1; 
     361nlf->problem=problem; 
     362} 
     363 
     364 
     365 
     366OptppQNewton::OptppQNewton() 
     367{ 
     368reset_signal.connect( boost::bind( &OptppQNewton::reset_OptppQNewton, this ) ); 
     369} 
     370 
     371 
     372void OptppQNewton::reset_OptppQNewton() 
     373{ 
     374if (problem.empty()) 
    136375   return; 
    137  
    138 if ((simple_app == 0) || (problem.application() != simple_app)) { 
    139    simple_app = new colin::SimplifiedConstraintInterface<colin::NLP0_problem>(problem.application()); 
    140    problem.set_application(simple_app); 
    141    } 
    142  
    143 colin::StdOptSolver<BasicArray<double>,colin::NLP0_problem>::reset(); 
    144  
    145 #if 0 
    146 if ((problem->numNonlinearEqConstraints()+problem->numLinearEqConstraints()) > 0) 
    147    EXCEPTION_MNGR(runtime_error, "Cobyla::reset - " << (problem->numNonlinearEqConstraints()+problem->numLinearEqConstraints()) << " equality constraints cannot be handled by cobyla!"); 
    148 #endif 
    149  
    150 if (problem->enforcing_bounds()) 
    151    problem->get_real_bounds(blower,bupper); 
    152 if (problem->numConstraints() > 0) 
    153    simple_app->get_constraint_bounds(clower,cupper); 
    154  
    155 x.resize(problem->num_real_vars()); 
    156 calcfc_point.resize(problem->num_real_vars()); 
    157 calcfc_cvec.resize(problem->numConstraints()); 
    158 calcfc_problem = &problem; 
    159 static_eval_mngr = eval_mngr(); 
    160 } 
    161  
    162  
    163 void Cobyla::minimize() 
    164 { 
    165 opt_init(); 
    166  
     376} 
     377 
     378 
     379void OptppQNewton::optimize() 
     380{ 
    167381int n=problem->num_real_vars(); 
    168382if (n == 0) { 
    169    best().termination_info = "No-Real-Params"; 
     383   solver_status.termination_info = "No-Real-Params"; 
    170384   return; 
    171385   } 
    172  
    173 x = initial_point; 
    174  
    175 // 
    176 // Compute the number of constraints, including bound constraints 
    177 // 
    178 int ncon=problem->numConstraints(); 
    179 int m=0; 
    180 if (problem->enforcing_bounds()) { 
    181    if (problem->finite_bound_constraints()) 
    182       m += 2*n; 
    183    else { 
    184       for (int i=0; i<n; i++) { 
    185         if (finite(blower[i])) m++; 
    186         if (finite(bupper[i])) m++; 
    187         } 
    188       } 
     386// 
     387// Get the initial point 
     388// 
     389if (initial_points->size( problem.application() ) == 0) { 
     390   solver_status.termination_info = "No-Initial-Point"; 
     391   return; 
    189392   } 
    190 if (ncon > 0) { 
    191    for (int i=0; i<ncon; i++) { 
    192      if (finite(clower[i])) m++; 
    193      if (finite(cupper[i])) m++; 
    194      } 
    195    } 
    196  
    197 int iprint=(debug>3 ? 3 : debug); 
    198  
    199 int tmp_neval; 
    200 if (max_neval > 0) { 
    201    tmp_neval = max(max_neval-neval(),0); 
    202    if (max_neval_curr != 0)  
    203       tmp_neval = min(tmp_neval, max_neval_curr); 
    204    } 
    205 else 
    206    tmp_neval = max_neval_curr; 
    207  
    208 int istatus = cobyla(n, m, &(x[0]), initial_step, step_tolerance, iprint, &tmp_neval, accuracy, calc_func,0); 
    209  
    210 switch (istatus) { 
    211   case COBYLA_ENOMEM: 
    212         best().termination_info="Memory-Errors"; 
    213         break; 
    214   case COBYLA_NORMAL: 
    215         best().termination_info="Step-Length"; 
    216         break; 
    217   case COBYLA_MAXFUN: 
    218         best().termination_info="Max-Num-Evals"; 
    219         break; 
    220   case COBYLA_ROUNDING: 
    221         best().termination_info="Roundoff-Errors"; 
    222         break; 
    223   case COBYLA_FUNCVAL: 
    224         best().termination_info="Accuracy"; 
    225         break; 
    226   default: 
    227         best().termination_info="Unknown"; 
    228         break; 
    229   }; 
     393if ( initial_points->size( problem.application() ) > 1 ) 
     394   solver_status.termination_info = "Too many initial points"; 
     395 
     396{ 
     397colin::AppRequest req = problem->set_domain(Any()); 
     398colin::AppResponse response = initial_points->getResponse(req); 
     399response.get_point(nlf->initial_point); 
     400} 
     401 
     402//initial_points->get_point(x); 
     403if (nlf->initial_point.size() != problem->num_real_vars()) 
     404   EXCEPTION_MNGR(std::runtime_error, "User-provided initial point has length " << nlf->initial_point.size() << " but the problem size is " << problem->num_real_vars() << std::endl); 
     405 
     406// 
     407// Run OPT++ 
     408// 
     409OPTPP::OptimizeClass* opt; 
     410if (problem->enforcing_domain_bounds()) { 
     411    opt = new OPTPP::OptBCQNewton(nlf,0); 
     412    } 
     413else { 
     414    opt = new OPTPP::OptQNewton(nlf,0); 
     415    } 
     416opt->optimize(); 
     417solver_status.termination_info = opt->getMesg(); 
     418NEWMAT::ColumnVector final_point = nlf->getXc(); 
     419delete opt; 
     420 
    230421// 
    231422// Collect info about the final point 
    232423// 
    233 best().point = x; 
    234 colin::AppRequest request = problem->set_domain(x); 
    235 problem->Request_response(request, best().response); 
    236 problem->Request_F(request, best().value()); 
    237 std::vector<real> viol; 
    238 simple_app->Request_CFViol(request, viol); 
    239 eval_mngr().perform_evaluation(request); 
    240 //std::cerr << "HERE " << viol << std::endl; 
    241 best().constraint_violation = colin::l2_norm_sq(viol); 
    242 } 
    243  
    244 } 
    245  
    246 FACTORY_REGISTER(cobyla, colin::OptSolverHandle*, 
    247                 return new colin::ConcreteOptSolverHandle<interfaces::Cobyla>;, 
    248                 "An alias to Cobyla") 
    249 FACTORY_REGISTER(Cobyla, colin::OptSolverHandle*, 
    250                 return new colin::ConcreteOptSolverHandle<interfaces::Cobyla>;, 
    251                 "The Cobyla2 derivative-free optimizer") 
     424//colin::AppRequest request = problem->set_domain(final_point); 
     425//problem->Request_F(request); 
     426//eval_mngr().perform_evaluation(request) ); 
     427final_points->insertResponse( problem->EvalF(final_point) ); 
     428} 
     429 
     430 
     431//REGISTER_COLIN_SOLVER(OptppQNewton, "optpp:newton1", "The OPT++ Newton method with for UNLP1 problems.") 
     432 
     433} 
    252434 
    253435#endif 
Note: See TracChangeset for help on using the changeset viewer.