Changeset 5727


Ignore:
Timestamp:
11/06/08 09:14:33 (5 years ago)
Author:
wehart
Message:

Further rework of OPT++ solver, to support solver options.

Location:
interfaces/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • interfaces/trunk/interfaces/OPTpp.h

    r5715 r5727  
    2222#include <colin/colin.h> 
    2323#include <colin/OptSolver.h> 
    24  
    25 namespace interfaces { 
     24#include <colin/CommonOptions.h> 
     25 
     26namespace interfaces 
     27{ 
    2628 
    2729/** A base class for NLP0 optimizers for OPT++ 
     
    3133public: 
    3234 
    33   /// Constructor 
    34   OptppNLP0(); 
    35  
    36   /// 
    37   ~OptppNLP0(); 
    38  
    39 private: 
    40  
    41   /// 
    42   OptppNLP0(const OptppNLP0& ) : nlf(0) {} 
    43  
    44   /// 
    45   OptppNLP0& operator=(const OptppNLP0& ) {return *this;} 
    46  
    47   /// 
    48   void reset_OptppNLP0(); 
    49  
    50 protected: 
    51  
    52   /// 
    53   class NLF0; 
    54  
    55   /// 
    56   NLF0* nlf; 
     35   /// Constructor 
     36   OptppNLP0(); 
     37 
     38   /// 
     39   ~OptppNLP0(); 
     40 
     41private: 
     42 
     43   /// 
     44   OptppNLP0(const OptppNLP0&) : nlf(0) {} 
     45 
     46   /// 
     47   OptppNLP0& operator=(const OptppNLP0&) {return *this;} 
     48 
     49   /// 
     50   void reset_OptppNLP0(); 
     51 
     52protected: 
     53 
     54   /// 
     55   class NLF0; 
     56 
     57   /// 
     58   NLF0* nlf; 
    5759 
    5860}; 
     
    6567public: 
    6668 
    67   /// Constructor 
    68   OptppNLP1(); 
    69  
    70   /// 
    71   ~OptppNLP1(); 
    72  
    73 private: 
    74  
    75   /// 
    76   OptppNLP1(const OptppNLP1& ) {} 
    77  
    78   /// 
    79   OptppNLP1& operator=(const OptppNLP1& ) {return *this;} 
    80  
    81   /// 
    82   void reset_OptppNLP1(); 
    83  
    84 protected: 
    85  
    86   /// 
    87   class NLF1; 
    88  
    89   /// 
    90   NLF1* nlf; 
    91  
    92 }; 
    93  
    94  
    95 #if 0 
     69   /// Constructor 
     70   OptppNLP1(); 
     71 
     72   /// 
     73   ~OptppNLP1(); 
     74 
     75private: 
     76 
     77   /// 
     78   OptppNLP1(const OptppNLP1&) {} 
     79 
     80   /// 
     81   OptppNLP1& operator=(const OptppNLP1&) {return *this;} 
     82 
     83   /// 
     84   void reset_OptppNLP1(); 
     85 
     86protected: 
     87 
     88   /// 
     89   class NLF1; 
     90 
     91   /// 
     92   NLF1* nlf; 
     93 
     94}; 
     95 
     96 
    9697/** A base class for NLP2 optimizers for OPT++ 
    9798  */ 
     
    100101public: 
    101102 
    102   /// Constructor 
    103   OptppNLP2(); 
    104  
    105 private: 
    106  
    107   /// 
    108   OptppNLP2(const OptppNLP2& ) {} 
    109  
    110   /// 
    111   OptppNLP2& operator=(const OptppNLP2& ) {return *this;} 
    112  
    113   /// 
    114   class NLF2; 
    115  
    116   /// 
    117   NLF2* nlf; 
    118  
    119   /// 
    120   void reset_OptppNLP2(); 
    121  
    122 }; 
    123 #endif 
    124  
     103   /// Constructor 
     104   OptppNLP2(); 
     105 
     106private: 
     107 
     108   /// 
     109   OptppNLP2(const OptppNLP2&) {} 
     110 
     111   /// 
     112   OptppNLP2& operator=(const OptppNLP2&) {return *this;} 
     113 
     114   /// 
     115   class NLF2; 
     116 
     117   /// 
     118   NLF2* nlf; 
     119 
     120   /// 
     121   void reset_OptppNLP2(); 
     122 
     123}; 
     124 
     125 
     126class NLFOptions 
     127{ 
     128public: 
     129 
     130   NLFOptions(utilib::OptionParser& option) 
     131   { 
     132      is_expensive = false; 
     133      option.add("expensive", is_expensive, 
     134                 "Determines whether or not function is expensive, in which case a value-based line-search is used instead of a gradient-based line-search"); 
     135 
     136      mode_override = false; 
     137      option.add("mode-override", mode_override, 
     138                 "Allow the function, gradient, and Hessian to be computed all in a single evaluation request"); 
     139 
     140      finitediff = "forward"; 
     141      option.add("gradient-fd", finitediff, 
     142                 "Set finite-difference approach for gradients: forward, backward, central.  This option only applies to FDNLF1 optimizers"); 
     143 
     144      option.add("fd-scaling", fcn_accuracy, 
     145                 "Set finite-difference scaling for all variables.  This option only to FDNLF1 optimizers."); 
     146 
     147      spec_grad = "none"; 
     148      option.add("spec-gradients", spec_grad, 
     149                 "Perform speculative gradient operations in parallel execution: no, spec1, or spec2. This option only applies to FDNLF1 optimizers"); 
     150   } 
     151 
     152   bool is_expensive; 
     153   bool mode_override; 
     154   std::string finitediff; 
     155   std::vector<double> fcn_accuracy; 
     156   std::string spec_grad; 
     157 
     158   template <class OptT, class NLFT, class ProblemT> 
     159   void set_options(OptT* opt, NLFT* nlf, ProblemT& problem) 
     160   { 
     161      nlf->setIsExpensive(is_expensive); 
     162      nlf->setModeOverride(mode_override); 
     163      if (finitediff == "forward") 
     164         nlf->setDerivOption(OPTPP::ForwardDiff); 
     165      else if (finitediff == "backward") 
     166         nlf->setDerivOption(OPTPP::BackwardDiff); 
     167      else if (finitediff == "central") 
     168         nlf->setDerivOption(OPTPP::CentralDiff); 
     169      else 
     170         EXCEPTION_MNGR(std::runtime_error, ucout << "ERROR: unexpected value for 'gradient-fd' option: " << finitediff << " Valid values are 'forward', 'backward' and 'central'."); 
     171      if (fcn_accuracy.size() == 0) 
     172      { 
     173         fcn_accuracy.resize(problem->num_real_vars()); 
     174         fcn_accuracy << DBL_EPSILON; 
     175      } 
     176      else if (fcn_accuracy.size() != problem->num_real_vars()) 
     177         EXCEPTION_MNGR(std::runtime_error, ucout << "ERROR: the value of the 'fd-scaling' option is an array with " << fcn_accuracy.size() << " values, but there are " << problem->num_real_vars() << " decision variables."); 
     178      NEWMAT::ColumnVector tmp; 
     179      utilib::TypeManager()->lexical_cast(fcn_accuracy, tmp); 
     180      nlf->setFcnAccrcy(tmp); 
     181      if (spec_grad == "none") 
     182         nlf->setSpecOption(OPTPP::NoSpec); 
     183      else if (spec_grad == "spec1") 
     184         nlf->setSpecOption(OPTPP::Spec1); 
     185      else if (spec_grad == "spec2") 
     186         nlf->setSpecOption(OPTPP::Spec2); 
     187      else 
     188         EXCEPTION_MNGR(std::runtime_error, ucout << "ERROR: unexpected value for 'spec-gradient' option: " << spec_grad << " Valid values are 'none', 'spec1' and 'spec2'."); 
     189 
     190   } 
     191 
     192}; 
     193 
     194class GenericOptions : public colin::CommonOptions 
     195{ 
     196public: 
     197 
     198   GenericOptions(utilib::OptionParser& option) 
     199         : colin::CommonOptions(option) 
     200   { 
     201      debug = false; 
     202      option.add("debug", debug, 
     203                 "Enable debugging output"); 
     204 
     205      double mcheps = DBL_EPSILON; 
     206 
     207      max_step_size = 1.0e+3; 
     208      option.add("max-step-size", max_step_size, 
     209                 "The maximum step length allowed"); 
     210 
     211      min_step_size = sqrt(mcheps); 
     212      option.add("min-step-size", min_step_size, 
     213                 "The minimum step length allowed"); 
     214 
     215      step_tol = sqrt(mcheps); 
     216      option.add("step-tolerance", step_tol, 
     217                 "The termination criteria based on step length"); 
     218 
     219      fcn_tol = sqrt(mcheps); 
     220      option.add("fn-tolerance", fcn_tol, 
     221                 "The termination criteria based on change in function value"); 
     222 
     223      con_tol = sqrt(mcheps); 
     224      option.add("feasibility-tolerance", con_tol, 
     225                 "The tolerance for constraint feasibility"); 
     226 
     227      grad_tol = pow(mcheps, 1.0 / 3.0); 
     228      option.add("gradient-tolerance", grad_tol, 
     229                 "The termination criteria based on gradient norm"); 
     230 
     231      linesearch_tol = 1.0e-4; 
     232      option.add("linesearch-tolerance", linesearch_tol, 
     233                 "The tolerance used for sufficient decrease in line search"); 
     234 
     235      max_backiter = 5; 
     236      option.add("max_backiter", max_backiter, 
     237                 "Maximum number of backtrack iterations allowed"); 
     238 
     239      max_neval = 1000; 
     240 
     241      sx << 1.0; 
     242      option.add("var_scale", sx, 
     243                 "Variable scaling"); 
     244   } 
     245 
     246   bool debug; 
     247   double max_step_size; 
     248   double min_step_size; 
     249   double step_tol; 
     250   double fcn_tol; 
     251   double con_tol; 
     252   double grad_tol; 
     253   double linesearch_tol; 
     254   int max_backiter; 
     255   std::vector<double> sx; 
     256 
     257 
     258   template <class OptT, class NLFT, class ProblemT> 
     259   void set_options(OptT* opt, NLFT* nlf, ProblemT& problem) 
     260   { 
     261      if (debug) 
     262         opt->setDebug(); 
     263      opt->setMaxStep(max_step_size); 
     264      opt->setMinStep(min_step_size); 
     265      opt->setStepTol(step_tol); 
     266      opt->setLineSearchTol(linesearch_tol); 
     267      opt->setMaxIter(max_iters); 
     268      opt->setMaxBacktrackIter(max_backiter); 
     269      opt->setMaxFeval(max_neval); 
     270      NEWMAT::ColumnVector tmp; 
     271      utilib::TypeManager()->lexical_cast(sx, tmp); 
     272      opt->setXScale(tmp); 
     273      opt->setOutputFile(std::cout); 
     274   } 
     275 
     276}; 
     277 
     278 
     279class NewtonOptions  
     280{ 
     281public: 
     282 
     283   NewtonOptions(utilib::OptionParser& option) 
     284   { 
     285strategy="TrustRegion"; 
     286option.add("search-strategy",strategy, 
     287    "Set the globalization strategy: LineSearch, TrustRegion, or TrustPDS"); 
     288 
     289TR_size=0.0; 
     290option.add("tr-size",TR_size, 
     291    "The size of the trust region.  If this is set to zero, then at runtime the trust  region is initialized to the gradient multiplier * norm of gradient"); 
     292 
     293gradMult=0.1; 
     294option.add("gradient-multiplier",gradMult, 
     295    "Multiplier for scaling gradient norm to set trust region size"); 
     296 
     297searchSize=64; 
     298option.add("trustPDS-size",searchSize, 
     299    "Number of pattern points for TrustPDS"); 
     300   } 
     301 
     302   std::string strategy; 
     303   double TR_size; 
     304   double gradMult; 
     305   unsigned int searchSize; 
     306 
     307   template <class OptT, class NLFT, class ProblemT> 
     308   void set_options(OptT* opt, NLFT* nlf, ProblemT& problem) 
     309   { 
     310   if (problem->enforcing_domain_bounds()) 
     311       opt->setSearchStrategy(OPTPP::LineSearch); 
     312    else { 
     313    if (strategy == "TrustRegion") 
     314       opt->setSearchStrategy(OPTPP::TrustRegion); 
     315    else if (strategy == "LineSearch") 
     316       opt->setSearchStrategy(OPTPP::LineSearch); 
     317    else if (strategy == "TrustPDS") 
     318       opt->setSearchStrategy(OPTPP::TrustPDS); 
     319    else 
     320       EXCEPTION_MNGR(std::runtime_error, "Unexpected value for option 'search-        strategy': '" << strategy << "'. Expected values are TrustRegion, LineSearch and       TrustPDS"); 
     321    } 
     322opt->setTRSize(TR_size); 
     323opt->setGradMult(gradMult); 
     324opt->setSearchSize(searchSize); 
     325   } 
     326 
     327}; 
    125328 
    126329/** An interface to the OPTpp Newton solver with NLP1 
    127330  */ 
    128 class OptppNewton1 : public OptppNLP1 
    129 { 
    130 public: 
    131  
    132   /// Constructor 
    133   OptppNewton1(); 
    134  
    135   /// 
    136   void optimize(); 
    137  
    138 protected: 
    139  
    140   /// 
    141   std::string define_solver_type() const 
    142         { return "optpp:newton_nlp1"; } 
    143  
    144   /// 
    145   bool using_fd_hessian; 
    146  
    147 private: 
    148  
    149   /// 
    150   void reset_OptppNewton1(); 
     331class OptppNewton1 : public OptppNLP1, public NLFOptions, public GenericOptions, public NewtonOptions 
     332{ 
     333public: 
     334 
     335   /// Constructor 
     336   OptppNewton1(); 
     337 
     338   /// 
     339   void optimize(); 
     340 
     341   /// 
     342   bool using_fd_hessian; 
     343 
     344protected: 
     345 
     346   /// 
     347   std::string define_solver_type() const 
     348      { return "optpp:newton_nlp1"; } 
     349 
     350private: 
     351 
     352   /// 
     353   void reset_OptppNewton1(); 
    151354 
    152355}; 
     
    155358/** An interface to the OPTpp NIPS solver with NLP1 
    156359  */ 
    157 class OptppNIPS1 : public OptppNLP1 
    158 { 
    159 public: 
    160  
    161   /// Constructor 
    162   OptppNIPS1(); 
    163  
    164   /// 
    165   void optimize(); 
    166  
    167 protected: 
    168  
    169   /// 
    170   std::string define_solver_type() const 
    171         { return "optpp:nips_nlp1"; } 
    172  
    173   /// 
    174   bool using_fd_hessian; 
    175  
    176 private: 
    177  
    178   /// 
    179   void reset_OptppNIPS1(); 
     360class OptppNIPS1 : public OptppNLP1, public NLFOptions, public GenericOptions 
     361{ 
     362public: 
     363 
     364   /// Constructor 
     365   OptppNIPS1(); 
     366 
     367   /// 
     368   void optimize(); 
     369 
     370   /// 
     371   bool using_fd_hessian; 
     372 
     373   std::string MeritFcn; 
     374   double sigmin; 
     375   double taumin; 
     376 
     377protected: 
     378 
     379   template <class OptT> 
     380   void set_options(OptT* opt) 
     381    { 
     382    if (MeritFcn == "NormFmu") 
     383        opt->setMeritFcn(OPTPP::NormFmu); 
     384    else if (MeritFcn == "ArgaezTapia") 
     385        opt->setMeritFcn(OPTPP::ArgaezTapia); 
     386    else if (MeritFcn == "VanShanno") 
     387        opt->setMeritFcn(OPTPP::VanShanno); 
     388    else 
     389        EXCEPTION_MNGR(std::runtime_error, "Unknown value for option 'merit-fn': '" << MeritFcn << "'. Expected NormFmu, ArgaezTapia or VanShanno"); 
     390    if (sigmin > 0.0) 
     391        opt->setCenteringParameter(sigmin); 
     392    if (taumin > 0.0) 
     393        opt->setStepLengthToBdry(sigmin); 
     394    } 
     395 
     396   /// 
     397   std::string define_solver_type() const 
     398      { return "optpp:nips_nlp1"; } 
     399 
     400private: 
     401 
     402   /// 
     403   void reset_OptppNIPS1(); 
    180404 
    181405}; 
     
    184408/** An interface to the OPTpp CG solver with NLP1 
    185409  */ 
    186 class OptppCG : public OptppNLP1 
    187 { 
    188 public: 
    189  
    190   /// Constructor 
    191   OptppCG(); 
    192  
    193   /// 
    194   void optimize(); 
    195  
    196 protected: 
    197  
    198   /// 
    199   std::string define_solver_type() const 
    200         { return "optpp:cg"; } 
    201  
    202 private: 
    203  
    204   /// 
    205   void reset_OptppCG(); 
     410class OptppCG : public OptppNLP1, public NLFOptions, public GenericOptions 
     411{ 
     412public: 
     413 
     414   /// Constructor 
     415   OptppCG(); 
     416 
     417   /// 
     418   void optimize(); 
     419 
     420protected: 
     421 
     422   /// 
     423   std::string define_solver_type() const 
     424      { return "optpp:cg"; } 
     425 
     426private: 
     427 
     428   /// 
     429   void reset_OptppCG(); 
    206430 
    207431}; 
     
    210434/** An interface to the OPTpp LBFGS solver with NLP1 
    211435  */ 
    212 class OptppLBFGS : public OptppNLP1 
    213 { 
    214 public: 
    215  
    216   /// Constructor 
    217   OptppLBFGS(); 
    218  
    219   /// 
    220   void optimize(); 
    221  
    222 protected: 
    223  
    224   /// 
    225   std::string define_solver_type() const 
    226         { return "optpp:lbfgs"; } 
    227  
    228 private: 
    229  
    230   /// 
    231   void reset_OptppLBFGS(); 
     436class OptppLBFGS : public OptppNLP1, public NLFOptions, public GenericOptions 
     437{ 
     438public: 
     439 
     440   /// Constructor 
     441   OptppLBFGS(); 
     442 
     443   /// 
     444   void optimize(); 
     445 
     446protected: 
     447 
     448   /// 
     449   std::string define_solver_type() const 
     450      { return "optpp:lbfgs"; } 
     451 
     452private: 
     453 
     454   /// 
     455   void reset_OptppLBFGS(); 
    232456 
    233457}; 
     
    236460/** An interface to the OPTpp PDS solver with NLP0 
    237461  */ 
    238 class OptppPDS : public OptppNLP0 
    239 { 
    240 public: 
    241  
    242   /// Constructor 
    243   OptppPDS(); 
    244  
    245   /// 
    246   void optimize(); 
    247  
    248 protected: 
    249  
    250   /// 
    251   std::string define_solver_type() const 
    252         { return "optpp:pds"; } 
    253  
    254 private: 
    255  
    256   /// 
    257   void reset_OptppPDS(); 
     462class OptppPDS : public OptppNLP0, public GenericOptions 
     463{ 
     464public: 
     465 
     466   /// Constructor 
     467   OptppPDS(); 
     468 
     469   /// 
     470   void optimize(); 
     471 
     472   int search_scheme_size; 
     473   int simplex_type; 
     474   std::vector<double> vscales; 
     475   NEWMAT::Matrix simplex_matrix; 
     476   std::string scheme_filename;  
     477 
     478protected: 
     479 
     480   /// 
     481   std::string define_solver_type() const 
     482      { return "optpp:pds"; } 
     483 
     484private: 
     485 
     486   /// 
     487   void reset_OptppPDS(); 
    258488 
    259489}; 
  • interfaces/trunk/src/lib/OPTpp.cpp

    r5715 r5727  
    5858bool optpp_lexical_casts() 
    5959{ 
    60    colin::ContextMngr().register_lexical_cast 
     60   utilib::TypeManager()->register_lexical_cast 
    6161      (typeid(NEWMAT::ColumnVector), 
    6262       typeid(std::vector<double>), 
    6363       &lexical_cast_from_newmat); 
    64    colin::ContextMngr().register_lexical_cast 
     64   utilib::TypeManager()->register_lexical_cast 
    6565      (typeid(std::vector<double>), 
    6666       typeid(NEWMAT::ColumnVector), 
     
    382382 
    383383OptppNewton1::OptppNewton1() 
     384    : NLFOptions(option), GenericOptions(option), NewtonOptions(option) 
    384385{ 
    385386reset_signal.connect( boost::bind( &OptppNewton1::reset_OptppNewton1, this ) ); 
    386387using_fd_hessian=false; 
     388option.add("fd-hessian",using_fd_hessian, 
     389    "If true, then use a Quasi-Newton method."); 
    387390} 
    388391 
     
    419422OPTPP::OptimizeClass* opt; 
    420423if (problem->enforcing_domain_bounds()) { 
    421     if (using_fd_hessian) 
    422         opt = new OPTPP::OptBCFDNewton(nlf,0); 
    423     else 
    424         opt = new OPTPP::OptBCQNewton(nlf,0); 
     424    if (using_fd_hessian) { 
     425        OPTPP::OptBCFDNewton* tmp = new OPTPP::OptBCFDNewton(nlf,0); 
     426        NLFOptions::set_options(tmp, nlf, problem); 
     427        GenericOptions::set_options(tmp, nlf, problem); 
     428        NewtonOptions::set_options(tmp, nlf, problem); 
     429        opt=tmp; 
     430        } 
     431    else { 
     432        OPTPP::OptBCQNewton* tmp = new OPTPP::OptBCQNewton(nlf,0); 
     433        NLFOptions::set_options(tmp, nlf, problem); 
     434        GenericOptions::set_options(tmp, nlf, problem); 
     435        NewtonOptions::set_options(tmp, nlf, problem); 
     436        opt=tmp; 
     437        } 
    425438    } 
    426439else { 
    427     if (using_fd_hessian) 
    428         opt = new OPTPP::OptFDNewton(nlf,0); 
    429     else 
    430         opt = new OPTPP::OptQNewton(nlf,0); 
     440    if (using_fd_hessian) { 
     441        OPTPP::OptFDNewton* tmp = new OPTPP::OptFDNewton(nlf,0); 
     442        NLFOptions::set_options(tmp, nlf, problem); 
     443        GenericOptions::set_options(tmp, nlf, problem); 
     444        NewtonOptions::set_options(tmp, nlf, problem); 
     445        opt=tmp; 
     446        } 
     447    else { 
     448        OPTPP::OptQNewton* tmp = new OPTPP::OptQNewton(nlf,0); 
     449        NLFOptions::set_options(tmp, nlf, problem); 
     450        GenericOptions::set_options(tmp, nlf, problem); 
     451        NewtonOptions::set_options(tmp, nlf, problem); 
     452        opt=tmp; 
     453        } 
    431454    } 
    432455opt->optimize(); 
     
    445468 
    446469OptppNIPS1::OptppNIPS1() 
     470    : NLFOptions(option), GenericOptions(option) 
    447471{ 
    448472reset_signal.connect( boost::bind( &OptppNIPS1::reset_OptppNIPS1, this ) ); 
     473 
    449474using_fd_hessian=false; 
     475option.add("fd-hessian",using_fd_hessian, 
     476    "If true, then use a Quasi-Newton method."); 
     477 
     478MeritFcn="ArgaezTapia"; 
     479option.add("merit-fn",MeritFcn, 
     480    "Set the merit function: NormFmu, ArgaezTapia, VanShanno"); 
     481 
     482sigmin=-1.0; 
     483option.add("centering",sigmin, 
     484    "Set centering parameter.  The default, -1, means 'unset'"); 
     485 
     486taumin=-1.0; 
     487option.add("boundary-step",taumin, 
     488    "Set percentage step toward boundary.  The default, -1, means 'unset'"); 
    450489} 
    451490 
     
    481520// 
    482521OPTPP::OptimizeClass* opt; 
    483 if (using_fd_hessian) 
    484     opt = new OPTPP::OptFDNIPS(nlf,0); 
    485 else 
    486     opt = new OPTPP::OptQNIPS(nlf,0); 
     522if (using_fd_hessian) { 
     523    OPTPP::OptFDNIPS* tmp = new OPTPP::OptFDNIPS(nlf,0); 
     524    NLFOptions::set_options(tmp, nlf, problem); 
     525    GenericOptions::set_options(tmp, nlf, problem); 
     526    set_options(tmp); 
     527    opt=tmp; 
     528    } 
     529else { 
     530    OPTPP::OptQNIPS* tmp = new OPTPP::OptQNIPS(nlf,0); 
     531    NLFOptions::set_options(tmp, nlf, problem); 
     532    GenericOptions::set_options(tmp, nlf, problem); 
     533    set_options(tmp); 
     534    opt=tmp; 
     535    } 
    487536opt->optimize(); 
    488537solver_status.termination_info = opt->getMesg(); 
     
    500549 
    501550OptppLBFGS::OptppLBFGS() 
     551    : NLFOptions(option), GenericOptions(option) 
    502552{ 
    503553reset_signal.connect( boost::bind( &OptppLBFGS::reset_OptppLBFGS, this ) ); 
     
    534584// Run OPT++ 
    535585// 
    536 OPTPP::OptimizeClass* opt = new OPTPP::OptLBFGS(nlf,0); 
     586OPTPP::OptLBFGS* opt = new OPTPP::OptLBFGS(nlf,0); 
     587NLFOptions::set_options(opt, nlf, problem); 
     588GenericOptions::set_options(opt, nlf, problem); 
    537589opt->optimize(); 
    538590solver_status.termination_info = opt->getMesg(); 
     
    550602 
    551603OptppCG::OptppCG() 
     604    : NLFOptions(option), GenericOptions(option) 
    552605{ 
    553606reset_signal.connect( boost::bind( &OptppCG::reset_OptppCG, this ) ); 
     
    584637// Run OPT++ 
    585638// 
    586 OPTPP::OptimizeClass* opt = new OPTPP::OptCG(nlf); 
     639OPTPP::OptCG* opt = new OPTPP::OptCG(nlf); 
     640NLFOptions::set_options(opt, nlf, problem); 
     641GenericOptions::set_options(opt, nlf, problem); 
    587642opt->optimize(); 
    588643solver_status.termination_info = opt->getMesg(); 
     
    600655 
    601656OptppPDS::OptppPDS() 
     657  : GenericOptions(option) 
    602658{ 
    603659reset_signal.connect( boost::bind( &OptppPDS::reset_OptppPDS, this ) ); 
     660 
     661search_scheme_size=64; 
     662option.add("scheme-size",search_scheme_size, 
     663    "Number of points in pattern to be evaluated at each iteration"); 
     664 
     665simplex_type=2; 
     666option.add("simplex",simplex_type, 
     667    "Type of simplex (1=right angle, 2=equal sides, 3=scaled right angle 4=user defined)"); 
     668 
     669option.add("scaling",vscales, 
     670    "Set variable scales"); 
     671 
     672// This is disabled until we can figure out how to support stream operators for 
     673// NEWMAT. 
     674//option.add("simplex-matrix",simplex_matrix, 
     675    //"Provide user-defined simplex"); 
     676 
     677scheme_filename="OptppPDS_pattern.txt"; 
     678option.add("scheme-file",scheme_filename, 
     679    "Name of file to hold pattern points"); 
    604680} 
    605681 
     
    632708   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); 
    633709// 
     710// Create and configure optimizer 
     711// 
     712OPTPP::OptPDS* opt = new OPTPP::OptPDS(nlf); 
     713GenericOptions::set_options(opt, nlf, problem); 
     714opt->setSSS(search_scheme_size); 
     715opt->setSimplexType(simplex_type); 
     716NEWMAT::ColumnVector tmp; 
     717utilib::TypeManager()->lexical_cast(vscales,tmp); 
     718opt->setScale(tmp); 
     719// Disabled.  See above. 
     720//opt->setSimplex(simplex_matrix); 
     721opt->setSchemeFileName(const_cast<char*>(scheme_filename.c_str())); 
     722// 
    634723// Run OPT++ 
    635724// 
    636 OPTPP::OptimizeClass* opt = new OPTPP::OptPDS(nlf); 
    637725opt->optimize(); 
    638726solver_status.termination_info = opt->getMesg(); 
     
    644732 
    645733 
    646 //REGISTER_COLIN_SOLVER(OptppNewton1, "optpp:newton1", "The OPT++ Newton method with for UNLP1 problems.") 
     734REGISTER_COLIN_SOLVER(OptppNewton1, "optpp:newton1", "The OPT++ Newton method for UNLP1 problems.") 
     735REGISTER_COLIN_SOLVER(OptppNIPS1, "optpp:nips1", "The OPT++ NIPS method for UNLP1 problems.") 
     736REGISTER_COLIN_SOLVER(OptppLBFGS, "optpp:lbfgs", "The OPT++ LBFGS method.") 
     737REGISTER_COLIN_SOLVER(OptppCG, "optpp:cg", "The OPT++ CG method.") 
     738REGISTER_COLIN_SOLVER(OptppPDS, "optpp:pds", "The OPT++ PDS method.") 
    647739 
    648740} 
Note: See TracChangeset for help on using the changeset viewer.