source: trunk/Bonmin/experimental/FP/FP.cpp @ 1

Last change on this file since 1 was 1, checked in by andreasw, 13 years ago

imported initial code

  • Property svn:eol-style set to native
  • Property svn:keywords set to "Author Date Id Revision"
File size: 7.7 KB
Line 
1// (C) Copyright International Business Machines Corporation and Carnegie Mellon University 2006
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// Authors :
6// Pierre Bonami, Carnegie Mellon University
7// Date:
8// 06/29/2006
9
10// Driver for Feasibility pump
11
12
13#if defined(_MSC_VER)
14// Turn off compiler warning about long names
15#  pragma warning(disable:4786)
16#endif
17#include <iomanip>
18#include <fstream>
19
20#include "CoinTime.hpp"
21
22#include "BonminAmplInterface.hpp"
23#include "BonminCbcParam.hpp"
24#include "CbcBonmin.hpp"
25#include "AmplTMINLP.hpp"
26#include "AmplTNLP.hpp"
27#include "FP.hpp"
28void register_ALL_options( SmartPtr<RegisteredOptions> roptions );
29void set_ipopt_minlp_default(SmartPtr<OptionsList> Option);
30
31
32
33class AmplFP : public Ipopt::AmplTMINLP
34{
35  public:
36  virtual void fillApplicationOptions2(Ipopt::AmplOptionsList* amplOptList)
37{
38   
39    amplOptList->AddAmplOption("FP.Algo","FP.Algo",
40                               AmplOptionsList::String_Option,
41                               "specify minimal investment in share");
42    amplOptList->AddAmplOption("FP.time_limit","FP.time_limit",
43                               AmplOptionsList::Number_Option,
44                               "Give time limit");
45}
46
47AmplFP(const SmartPtr<const Journalist>& jnlst, 
48           const SmartPtr<OptionsList> options,
49           char**& argv, 
50           AmplSuffixHandler* suffix_handler /*=NULL*/,
51           const std::string& appName,
52           std::string* nl_file_content /* = NULL */):AmplTMINLP()
53           {
54               std::cout<<"Toto"<<std::endl;
55               Initialize2(jnlst, options, argv, suffix_handler,
56               appName, nl_file_content);
57          }
58virtual void
59Initialize2(const SmartPtr<const Journalist>& jnlst, 
60           const SmartPtr<OptionsList> options,
61           char**& argv, 
62           AmplSuffixHandler* suffix_handler =NULL,
63           const std::string& appName = "fp",
64           std::string* nl_file_content  = NULL )
65           {
66  SmartPtr<AmplOptionsList> ampl_options_list = new AmplOptionsList();
67  fillAmplOptionList(GetRawPtr(ampl_options_list));
68  fillApplicationOptions2(GetRawPtr(ampl_options_list) );
69  std::string options_id = appName + "_options";
70  ampl_tnlp_ = new AmplTNLP(jnlst, options, argv, suffix_handler, true,
71                            ampl_options_list, options_id.c_str(),
72                            appName.c_str(), appName.c_str(), nl_file_content);
73           }
74           public:
75           AmplFP():AmplTMINLP(){}
76           virtual AmplTMINLP * createEmpty(){return new AmplFP;}
77};
78
79class FPInterface : public BonminAmplInterface
80{
81public:
82  FPInterface(char **& argv):BonminAmplInterface()
83  {
84    readAmplNlFile2(argv);
85  }
86  FPInterface(const FPInterface &other):
87  BonminAmplInterface(other)
88  {std::cout<<"Holla soy aqui"<<std::endl;}
89  virtual OsiSolverInterface * clone()
90  { return new FPInterface(*this);} 
91protected:
92  virtual std::string appName() {return "FP";}
93  virtual void registerApplicationOptions(Ipopt::SmartPtr<Ipopt::RegisteredOptions> roptions)
94  {
95    roptions->SetRegisteringCategory("FP options");
96    roptions->AddStringOption4("Algo","type of FP algorithm",
97                               "FP",
98                               "FP", "Stand-alone FP",
99                               "iFP", "iterated FP",
100                               "OA", "Classical OA",
101                               "eOA","Enhanced OA"
102                               "");
103  }
104  void 
105  readAmplNlFile2(char**& filename
106                  )
107  {
108    app_ = new Ipopt::IpoptApplication();
109    SmartPtr<RegisteredOptions> roptions = app_->RegOptions();
110    register_ALL_options(roptions);
111    registerApplicationOptions(roptions);
112   
113    // Call initalize to open output
114    app_->Initialize("");
115    // Read the bonmin.opt input file
116    app_->Initialize("FP.opt");
117   
118    char * pbName = new char[strlen(filename[1])+1];
119    strcpy(pbName, filename[1]);
120   
121    setStrParam(OsiProbName,std::string(pbName));
122    delete [] pbName;
123   
124    // set the default options... expect_infeasible, etc...
125    set_ipopt_minlp_default(app_->Options());
126   
127    if(!IsValid(tminlp_)) {
128      amplTminlp_ = new AmplFP(ConstPtr(app_->Jnlst()), app_->Options(), filename,
129                               NULL, appName() , NULL);
130      tminlp_ = GetRawPtr(amplTminlp_);
131    }
132    else {
133      AmplTMINLP * amplTMINLP = dynamic_cast<AmplTMINLP *> (GetRawPtr(tminlp_));
134      if(amplTMINLP) {
135        AmplTMINLP * newAmpl = amplTMINLP->createEmpty();
136        newAmpl->Initialize(ConstPtr(app_->Jnlst()), app_->Options(), filename,
137                            NULL, appName() , NULL);
138        amplTminlp_ = newAmpl;
139        tminlp_ = GetRawPtr(amplTminlp_);
140      }
141      else {
142        amplTminlp_ = new AmplFP(ConstPtr(app_->Jnlst()), app_->Options(), filename,
143                                     NULL, appName() , NULL);
144        tminlp_ = GetRawPtr(amplTminlp_);
145      }
146    }
147    problem_ = new Ipopt::TMINLP2TNLP(tminlp_, *app_->Options());
148   
149    bool print_options_documentation;
150    app_->Options()->GetBoolValue("print_options_documentation",
151                                  print_options_documentation, "");
152    if (print_options_documentation) {
153      std::list<std::string> categories;
154      categories.push_back("FP options");
155      //    roptions->OutputLatexOptionDocumentation2(*app_->Jnlst(),categories);
156      roptions->OutputOptionDocumentation(*app_->Jnlst(),categories);
157    }
158   
159    int numcols = getNumCols();
160    if(obj_)
161      delete [] obj_;
162    obj_ = new double[numcols];
163    CoinFillN(obj_,numcols,1.);
164    setStrParam(OsiProbName, std::string(filename[1]));
165    extractInterfaceParams();
166    hasBeenOptimized_ = false;
167    feasibilityProblem_ = new Ipopt::TNLP2FPNLP
168      (Ipopt::SmartPtr<Ipopt::TNLP>(Ipopt::GetRawPtr(problem_)));
169  }
170};
171
172int iteratedFP(BonminAmplInterface &nlpSolver, 
173               bool standAlone, 
174               double *&solution);
175
176int enhancedOA(BonminAmplInterface &nlpSolver, 
177               bool doFP, 
178               double *&solution);
179
180int main (int argc, char *argv[])
181{
182  using namespace Ipopt;
183 
184  FPInterface nlpSolver(argv);
185 
186                           
187  //Set up done, now let's branch and bound
188  double time1 = CoinCpuTime();
189  try {
190    Ipopt::SmartPtr<Ipopt::OptionsList> Options = nlpSolver.retrieve_options();
191   
192    int algo;
193   
194    Options->GetEnumValue("Algo", algo, "FP.");
195    Options->GetNumericValue("time_limit",params.maxTime_,"FP.");
196    double * solution = NULL;
197    if(algo==0)
198      iteratedFP(nlpSolver,1, solution);
199    else if (algo==1)
200      iteratedFP(nlpSolver,0, solution);
201    else if(algo==2)
202      enhancedOA(nlpSolver,0, solution);
203    else if(algo==3)
204      enhancedOA(nlpSolver,1, solution);
205   
206    std::string message;
207    if(solution==NULL) message="No solution";
208      else message="Solution found";
209    nlpSolver.writeAmplSolFile(message,solution,NULL);
210   
211  }
212  catch(IpoptInterface::UnsolvedError &E) {
213    //There has been a failure to solve a problem with Ipopt.
214    //And we will output file with information on what has been changed in the problem to make it fail.
215    //Now depending on what algorithm has been called (B-BB or other) the failed problem may be at different place.
216    //    const OsiSolverInterface &si1 = (algo > 0) ? nlpSolver : *model.solver();
217
218  }
219  catch(IpoptInterface::SimpleError &E) {
220    std::cerr<<E.className()<<"::"<<E.methodName()
221    <<std::endl
222    <<E.message()<<std::endl;
223  }
224  catch(CoinError &E) {
225    std::cerr<<E.className()<<"::"<<E.methodName()
226    <<std::endl
227    <<E.message()<<std::endl;
228  }
229  catch(...) {
230    std::string pbName;
231   
232    nlpSolver.getStrParam(OsiProbName, pbName);
233
234    std::cerr<<pbName<<" unrecognized excpetion"<<std::endl;
235    std::cerr<<pbName<<"\t Finished \t exception"<<std::endl;
236    throw;
237  }
238 
239  return 0;
240}
241
242
Note: See TracBrowser for help on using the repository browser.