00001
00015 #include "OSRunSolver.h"
00016 #include "OSCoinSolver.h"
00017 #include "OSResult.h"
00018 #include "OSrLWriter.h"
00019 #include "OSInstance.h"
00020 #include "OSOption.h"
00021 #include "OSConfig.h"
00022 #include "OSDefaultSolver.h"
00023 #include "OSErrorClass.h"
00024
00025 #ifdef COIN_HAS_KNITRO
00026 #include "OSKnitroSolver.h"
00027 #endif
00028
00029 #ifdef COIN_HAS_LINDO
00030 #include "OSLindoSolver.h"
00031 #endif
00032
00033 #ifdef COIN_HAS_IPOPT
00034 #ifndef COIN_HAS_ASL
00035 #include "OSIpoptSolver.h"
00036 #undef COIN_HAS_ASL
00037 #else
00038 #include "OSIpoptSolver.h"
00039 #endif
00040 #endif
00041
00042 #ifdef COIN_HAS_BONMIN
00043 #include "OSBonminSolver.h"
00044 #endif
00045
00046 #ifdef COIN_HAS_COUENNE
00047 #include "OSCouenneSolver.h"
00048 #endif
00049
00050 #include <stdio.h>
00051 #include <map>
00052
00053
00054 using std::cout;
00055 using std::endl;
00056 using std::ostringstream;
00057 using std::string;
00058 using std::map;
00059
00060
00061 std::string runSolver(std::string solverName, std::string osol,
00062 OSInstance *osinstance)
00063 {
00064 DefaultSolver *solverType = NULL;
00065 solverType = selectSolver(solverName, osinstance);
00066 if (solverType == NULL)
00067 throw ErrorClass("No appropriate solver found");
00068
00069
00070 solverType->osinstance = osinstance;
00071 solverType->osol = osol;
00072 solverType->buildSolverInstance();
00073 solverType->setSolverOptions();
00074 solverType->solve();
00075 std::string resultString = solverType->osrl;
00076 if (solverType != NULL)
00077 delete solverType;
00078 solverType = NULL;
00079 return resultString;
00080 }
00081
00082
00083 std::string runSolver(std::string solverName, OSOption* osoption,
00084 OSInstance *osinstance)
00085 {
00086 DefaultSolver *solverType = NULL;
00087 solverType = selectSolver(solverName, osinstance);
00088 if (solverType == NULL)
00089 throw ErrorClass("No appropriate solver found");
00090
00091
00092 solverType->osinstance = osinstance;
00093 solverType->osoption = osoption;
00094 solverType->buildSolverInstance();
00095 solverType->setSolverOptions();
00096 solverType->solve();
00097 std::string resultString = solverType->osrl;
00098 if (solverType != NULL)
00099 delete solverType;
00100 solverType = NULL;
00101 return resultString;
00102 }
00103
00104
00105
00106 std::string runSolver(std::string solverName, std::string osol,
00107 std::string osil)
00108 {
00109 OSInstance* osinstance = new OSInstance();
00110 OSiLReader* osilreader = new OSiLReader();
00111
00112 DefaultSolver *solverType = NULL;
00113
00114 osinstance = osilreader->readOSiL(osil);
00115
00116 solverType = selectSolver(solverName, osinstance);
00117 if (solverType == NULL)
00118 throw ErrorClass("No appropriate solver found");
00119
00120
00121 solverType->osinstance = osinstance;
00122 solverType->osol = osol;
00123 solverType->buildSolverInstance();
00124 solverType->setSolverOptions();
00125 solverType->solve();
00126 std::string resultString = solverType->osrl;
00127 if (solverType != NULL)
00128 delete solverType;
00129 solverType = NULL;
00130 delete osilreader;
00131 osilreader = NULL;
00132 return resultString;
00133 }
00134
00135
00136 std::string runSolver(std::string solverName, OSOption* osoption,
00137 std::string osil)
00138 {
00139 OSInstance* osinstance = new OSInstance();
00140 OSiLReader* osilreader = new OSiLReader();
00141
00142 DefaultSolver *solverType = NULL;
00143
00144 osinstance = osilreader->readOSiL(osil);
00145
00146 solverType = selectSolver(solverName, osinstance);
00147 if (solverType == NULL)
00148 throw ErrorClass("No appropriate solver found");
00149
00150
00151 solverType->osinstance = osinstance;
00152 solverType->osoption = osoption;
00153 solverType->buildSolverInstance();
00154 solverType->setSolverOptions();
00155 solverType->solve();
00156 std::string resultString = solverType->osrl;
00157 if (solverType != NULL)
00158 delete solverType;
00159 solverType = NULL;
00160 delete osilreader;
00161 osilreader = NULL;
00162 return resultString;
00163 }
00164
00165
00166
00167 DefaultSolver* selectSolver(std::string solverName, OSInstance *osinstance)
00168 {
00169 DefaultSolver *solverType = NULL;
00170 try
00171 {
00172 if (solverName == "")
00173 {
00174 if (osinstance == NULL)
00175 throw ErrorClass(
00176 "there was a NULL instance sent to buildSolver");
00177
00178 if (osinstance->getNumberOfIntegerVariables()
00179 + osinstance->getNumberOfBinaryVariables() > 0)
00180 {
00181 if ((osinstance->getNumberOfNonlinearExpressions() > 0)
00182 || (osinstance->getNumberOfQuadraticTerms() > 0))
00183 {
00184 solverName = "bonmin";
00185 }
00186 else
00187 {
00188 solverName = "cbc";
00189 }
00190 }
00191 else
00192 {
00193 if ((osinstance->getNumberOfNonlinearExpressions() > 0)
00194 || (osinstance->getNumberOfQuadraticTerms() > 0))
00195 {
00196 solverName = "ipopt";
00197 }
00198 else
00199 {
00200 solverName = "clp";
00201 }
00202 }
00203 }
00204
00205
00206
00207
00208
00209 if (solverName.find("ipopt") != std::string::npos)
00210 {
00211
00212
00213 #ifdef COIN_HAS_IPOPT
00214 solverType = new IpoptSolver();
00215 solverType->sSolverName = "ipopt";
00216 #else
00217 throw ErrorClass("the Ipopt solver requested is not present");
00218 #endif
00219 }
00220 else
00221 {
00222 if (solverName.find("lindo") != std::string::npos)
00223 {
00224
00225 #ifdef COIN_HAS_LINDO
00226 solverType = new LindoSolver();
00227 solverType->sSolverName = "lindo";
00228 #else
00229 throw ErrorClass( "the Lindo solver requested is not present");
00230 #endif
00231 }
00232 else
00233 {
00234 if (solverName.find("clp") != std::string::npos)
00235 {
00236
00237 solverType = new CoinSolver();
00238
00239 solverType->sSolverName = "clp";
00240 }
00241 else
00242 {
00243 if (solverName.find("cplex") != std::string::npos)
00244 {
00245 #ifdef COIN_HAS_CPX
00246 solverType = new CoinSolver();
00247 solverType->sSolverName = "cplex";
00248 #else
00249 throw ErrorClass( "the Cplex solver requested is not present");
00250 #endif
00251 }
00252 else
00253 {
00254 if (solverName.find("glpk") != std::string::npos)
00255 {
00256 #ifdef COIN_HAS_GLPK
00257 solverType = new CoinSolver();
00258 solverType->sSolverName = "glpk";
00259 #else
00260 throw ErrorClass( "the GLPK solver requested is not present");
00261 #endif
00262 }
00263 else
00264 {
00265 if (solverName.find("dylp") != std::string::npos)
00266 {
00267 #ifdef COIN_HAS_DYLP
00268 solverType = new CoinSolver();
00269 solverType->sSolverName = "dylp";
00270 #else
00271 throw ErrorClass( "the DyLP solver requested is not present");
00272 #endif
00273 }
00274 else
00275 {
00276 if (solverName.find("symphony")
00277 != std::string::npos)
00278 {
00279 #ifdef COIN_HAS_SYMPHONY
00280 solverType = new CoinSolver();
00281 solverType->sSolverName = "symphony";
00282 #else
00283 throw ErrorClass( "the SYMPHONY solver requested is not present");
00284 #endif
00285 }
00286 else
00287 {
00288 if (solverName.find("knitro")
00289 != std::string::npos)
00290 {
00291 #ifdef COIN_HAS_KNITRO
00292
00293 solverType = new KnitroSolver();
00294 solverType->sSolverName = "knitro";
00295
00296 #else
00297 throw ErrorClass( "the Knitro solver requested is not present");
00298 #endif
00299 }
00300 else
00301 {
00302 if (solverName.find("vol")
00303 != std::string::npos)
00304 {
00305 #ifdef COIN_HAS_VOL
00306 solverType = new CoinSolver();
00307 solverType->sSolverName = "vol";
00308 #else
00309 throw ErrorClass( "the Vol solver requested is not present");
00310 #endif
00311 }
00312 else
00313 {
00314 if (solverName.find("bonmin")
00315 != std::string::npos)
00316 {
00317
00318 #ifdef COIN_HAS_BONMIN
00319 solverType = new BonminSolver();
00320 solverType->sSolverName = "bonmin";
00321 #else
00322 throw ErrorClass( "the Bonmin solver requested is not present");
00323 #endif
00324 }
00325 else
00326 {
00327 if (solverName.find("couenne")
00328 != std::string::npos)
00329 {
00330
00331 #ifdef COIN_HAS_COUENNE
00332 solverType = new CouenneSolver();
00333 solverType->sSolverName = "couenne";
00334 #else
00335 throw ErrorClass( "the Couenne solver requested is not present");
00336 #endif
00337 }
00338 else
00339 {
00340 if(solverName.find("cbc") != std::string::npos)
00341 {
00342 solverType = new CoinSolver();
00343 solverType->sSolverName = "cbc";
00344 }
00345 else
00346 {
00347 std::string errorMessage;
00348 errorMessage = "solver type " + solverName + " is not supported";
00349 throw ErrorClass( errorMessage );
00350
00351
00352 }
00353 }
00354 }
00355 }
00356 }
00357 }
00358 }
00359 }
00360 }
00361 }
00362 }
00363 }
00364
00365 return solverType;
00366 }
00367
00368 catch (const ErrorClass& eclass)
00369 {
00370 if (solverType != NULL)
00371 delete solverType;
00372 solverType = NULL;
00373 throw eclass;
00374 return NULL;
00375 }
00376
00377 }
00378
00379