My Project
OSCoinSolver.cpp
Go to the documentation of this file.
1 /* $Id$ */
19 #include "OSCoinSolver.h"
20 #include "OSInstance.h"
21 #include "OSFileUtil.h"
22 #include "OSOutput.h"
23 #include "CoinTime.hpp"
24 #include "CglPreProcess.hpp"
25 #include "CglGomory.hpp"
26 #include "CglSimpleRounding.hpp"
27 #include "CglMixedIntegerRounding2.hpp"
28 #include "CglKnapsackCover.hpp"
29 #include "CglFlowCover.hpp"
30 #include "CbcBranchActual.hpp" //for CbcSOS
31 #include "CoinMessageHandler.hpp"
32 #include "CoinMessage.hpp"
33 
34 #include "OsiClpSolverInterface.hpp"
35 #include "CoinWarmStartBasis.hpp"
36 #include "CbcSolver.hpp"
37 
38 #ifdef COIN_HAS_SYMPHONY
39 #include "OsiSymSolverInterface.hpp"
40 #endif
41 
42 #ifdef COIN_HAS_VOL
43 #include "OsiVolSolverInterface.hpp"
44 #endif
45 
46 #ifdef COIN_HAS_DYLP
47 #include "OsiDylpSolverInterface.hpp"
48 #endif
49 
50 #ifdef COIN_HAS_GLPK
51 #include "OsiGlpkSolverInterface.hpp"
52 #endif
53 
54 #ifdef COIN_HAS_CPX
55 #include "OsiCpxSolverInterface.hpp"
56 #endif
57 
58 #ifdef COIN_HAS_GRB
59 #include "OsiGrbSolverInterface.hpp"
60 #endif
61 
62 #ifdef COIN_HAS_MSK
63 #include "OsiMskSolverInterface.hpp"
64 #endif
65 
66 #ifdef COIN_HAS_SOPLEX
67 #include "OsiSpxSolverInterface.hpp"
68 #endif
69 
70 #ifdef COIN_HAS_XPR
71 #include "OsiXprSolverInterface.hpp"
72 #endif
73 
74 #include "OSGeneral.h"
75 #include "OSParameters.h"
76 #include "OSMathUtil.h"
77 
78 #include <map>
79 
80 #include <iostream>
81 #ifdef HAVE_CTIME
82 # include <ctime>
83 #else
84 # ifdef HAVE_TIME_H
85 # include <time.h>
86 # else
87 # error "don't have header file for time"
88 # endif
89 #endif
90 
91 using std::cout;
92 using std::endl;
93 using std::ostringstream;
94 
95 
96 
98  osiSolver(NULL),
99  m_osilreader(NULL),
100  m_osolreader(NULL),
101  m_CoinPackedMatrix(NULL),
102  cbc_argv( NULL),
103  num_cbc_argv( 0),
104  cpuTime( 0)
105 {
106  osrlwriter = new OSrLWriter();
107 }
108 
110 {
111 #ifndef NDEBUG
113  ENUM_OUTPUT_LEVEL_debug, "inside CoinSolver destructor\n");
114 #endif
115  if(m_osilreader != NULL) delete m_osilreader;
116  m_osilreader = NULL;
117  if(m_osolreader != NULL) delete m_osolreader;
118  m_osolreader = NULL;
119  delete m_CoinPackedMatrix;
120  m_CoinPackedMatrix = NULL;
121  delete osiSolver;
122  if(osiSolver != NULL) osiSolver = NULL;
123  delete osrlwriter;
124  osrlwriter = NULL;
125  delete osresult;
126  osresult = NULL;
127  if(num_cbc_argv > 0)
128  {
129 /* -----
130  int i;
131  for(i = 0; i < num_cbc_argv; i++)
132  {
133  delete cbc_argv[ i];
134  }
135  delete[] cbc_argv;
136  ----- */
137  cbc_argv = NULL;
138  }
139 #ifndef NDEBUG
141  ENUM_OUTPUT_LEVEL_trace, "Leaving CoinSolver destructor\n");
142 #endif
143 }
144 
145 
147 {
148  std::ostringstream outStr;
149  try
150  {
151  if(osil.length() == 0 && osinstance == NULL) throw ErrorClass("there is no instance");
152  clock_t start, finish;
153  double duration;
154  start = clock();
155  if(osinstance == NULL)
156  {
157  m_osilreader = new OSiLReader();
159  }
160  finish = clock();
161  duration = (double) (finish - start) / CLOCKS_PER_SEC;
162 
163  // Can't handle multiobjective problems properly --- especially nonlinear ones
164  if (osinstance->getObjectiveNumber() > 1)
165  throw ErrorClass("Solver cannot handle multiple objectives --- please delete all but one");
166 
167  // get the type of solver requested from OSoL string
168  if (sSolverName == "clp")
169  osiSolver = new OsiClpSolverInterface();
170 
171  else if (sSolverName == "cbc")
172  osiSolver = new OsiClpSolverInterface();
173 
174  else if (sSolverName == "vol")
175  #ifdef COIN_HAS_VOL
176  osiSolver = new OsiVolSolverInterface();
177  #else
178  throw ErrorClass("This OSSolverService was built without solver vol");
179  #endif
180 
181  else if (sSolverName == "cplex")
182  #ifdef COIN_HAS_CPX
183  osiSolver = new OsiCpxSolverInterface();
184  #else
185  throw ErrorClass("This OSSolverService was built without solver cplex");
186  #endif
187 
188  else if (sSolverName == "gurobi")
189  #ifdef COIN_HAS_GRB
190  osiSolver = new OsiGrbSolverInterface();
191  #else
192  throw ErrorClass("This OSSolverService was built without solver gurobi");
193  #endif
194 
195  else if (sSolverName == "mosek")
196  #ifdef COIN_HAS_MSK
197  osiSolver = new OsiMskSolverInterface();
198  #else
199  throw ErrorClass("This OSSolverService was built without solver mosek");
200  #endif
201 
202  else if (sSolverName == "soplex")
203  #ifdef COIN_HAS_SOPLEX
204  osiSolver = new OsiSpxSolverInterface();
205  #else
206  throw ErrorClass("This OSSolverService was built without solver soplex");
207  #endif
208 
209  else if (sSolverName == "xpress")
210  #ifdef COIN_HAS_XPR
211  osiSolver = new OsiXprSolverInterface();
212  #else
213  throw ErrorClass("This OSSolverService was built without solver xpress");
214  #endif
215 
216  else if (sSolverName == "glpk")
217  #ifdef COIN_HAS_GLPK
218  osiSolver = new OsiGlpkSolverInterface();
219  #else
220  throw ErrorClass("This OSSolverService was built without solver glpk");
221  #endif
222 
223  else if (sSolverName == "dylp")
224  #ifdef COIN_HAS_DYLP
225  osiSolver = new OsiDylpSolverInterface();
226  #else
227  throw ErrorClass("This OSSolverService was built without solver dylp");
228  #endif
229 
230  else if (sSolverName == "symphony")
231  #ifdef COIN_HAS_SYMPHONY
232  osiSolver = new OsiSymSolverInterface();
233  #else
234  throw ErrorClass("This OSSolverService was built without solver symphony");
235  #endif
236 
237  else if (sSolverName == "")
238  { // default solver is Clp in continuous case,
239  // Cbc for an integer program
241  sSolverName.find( "cbc") != std::string::npos ) sSolverName = "cbc";
242  else sSolverName = "clp";
243  osiSolver = new OsiClpSolverInterface();
244  }
245  else
246  throw ErrorClass("Solver selected is not supported by this version of OSSolverService");
247 
248  // first check the various solvers and see if they support the given problem type
250  {
251  throw ErrorClass( "This COIN-OR Solver is not configured for nonlinear programming");
252  }
253  if ((osinstance->getNumberOfQuadraticTerms() > 0) &&
254  (sSolverName.find( "cbc") == std::string::npos) &&
255  (sSolverName.find( "clp") == std::string::npos))
256  {
257  throw ErrorClass( "This COIN-OR Solver is not configured for quadratic programming");
258  }
259  // throw an exception if we have a solver that cannot do integer programming
261  {
262  if( sSolverName.find("clp") != std::string::npos)
263  throw ErrorClass( "Clp cannot do integer programming");
264  if( sSolverName.find("vol") != std::string::npos)
265  throw ErrorClass( "Vol cannot do integer programming");
266  if( sSolverName.find("dylp") != std::string::npos)
267  throw ErrorClass( "DyLP cannot do integer programming");
268  if( sSolverName.find("soplex") != std::string::npos)
269  throw ErrorClass( "SoPlex cannot do integer programming");
270  }
271  // throw an exception if we have a solver that cannot handle semi-continuous or semi-integer variables
273  {
274  throw ErrorClass( "Semi-integer and semi-continuous variables not supported");
275  //if( sSolverName.find("clp") != std::string::npos) throw ErrorClass( "Clp cannot do semi-integer variables");
276  //if( sSolverName.find("vol") != std::string::npos) throw ErrorClass( "Vol cannot do semi-integer variables");
277  //if( sSolverName.find("dylp") != std::string::npos) throw ErrorClass( "DyLP cannot do semi-integer variables");
278  //if( sSolverName.find("soplex") != std::string::npos) throw ErrorClass( "SoPlex cannot do semi-integer variables");
279  }
280  // check other trivial solver limitations
281  //if(osinstance->getConstraintNumber() <= 0)throw ErrorClass("Coin solver:" + sSolverName +" cannot handle unconstrained problems");
282  //if(osinstance->getVariableNumber() <= 0)throw ErrorClass("Coin solver requires decision variables");
283  if(osinstance->getObjectiveNumber() <= 0)
284  throw ErrorClass("Coin solver: " + sSolverName + " needs an objective function");
286  throw ErrorClass("Coin solver: " + sSolverName + " can only handle numeric variables");
287  if(osinstance->getLinearConstraintCoefficientNumber() <= 0 && sSolverName == "symphony")
288  throw ErrorClass("Coin solver: " + sSolverName + " needs a positive number of constraints");
289 
290  if(!setCoinPackedMatrix() ) throw ErrorClass("Problem generating coin packed matrix");
296  );
297 #ifndef NDEBUG
298  //dataEchoCheck();
299 #endif
300  if( osinstance->getObjectiveMaxOrMins()[0] == "min") osiSolver->setObjSense(1.0);
301  else osiSolver->setObjSense(-1.0);
302  // set the integer variables
303  int numOfIntVars
305  if (numOfIntVars > 0)
306  {
307  int *intIndex = NULL;
308  int i = 0;
309  int k = 0;
310  char *varType;
311  intIndex = new int[ numOfIntVars];
312  varType = osinstance->getVariableTypes();
313  for(i = 0; i < osinstance->getVariableNumber(); i++)
314  {
315  if( (varType[i] == 'B') || (varType[i]) == 'I' )
316  {
317  intIndex[k++] = i;
318  }
319  }
320  osiSolver->setInteger( intIndex, numOfIntVars);
321 
322  delete[] intIndex;
323  intIndex = NULL;
324  }
325 
326  // the clpSolver supports quadratic objectives if present in the input
328  if (nq > 0)
329  {
330  if ( (sSolverName.find("clp") != std::string::npos) )
331  {
332  // get quadratic data, verify objective terms only, convert to sparse matrix format
334 
335 #ifndef NDEBUG
336  outStr.str("");
337  outStr.clear();
338  outStr << "original arrays:" << std::endl;
339  outStr << " var One indexes:";
340  for (int i=0; i<nq; i++)
341  outStr << " " << qterms->varOneIndexes[i];
342  outStr << std::endl;
343  outStr << " var Two indexes:";
344  for (int i=0; i<nq; i++)
345  outStr << " " << qterms->varTwoIndexes[i];
346  outStr << std::endl;
347  outStr << " coefficients: ";
348  for (int i=0; i<nq; i++)
349  outStr << " " << qterms->coefficients[i];
350  outStr << std::endl;
352  ENUM_OUTPUT_LEVEL_trace, outStr.str());
353 #endif
354 
355  int ncols = osinstance->getVariableNumber();
356  int* colStarts = new int[ncols+1];
357  for (int i=0; i<=ncols; i++)
358  colStarts[i] = 0;
359 
360  //get column lengths
361  for (int i=0; i<nq; i++)
362  {
363  if (qterms->rowIndexes[i] != -1)
364  throw ErrorClass("Clp solver cannot handle quadratic terms in the constraints");
365  else
366  colStarts[qterms->varOneIndexes[i]+1] += 1;
367  }
368 
369  // convert column lengths to column starts
370  for (int i=0; i<ncols; i++)
371  colStarts[i+1] += colStarts[i];
372 
373  // sort the varOneIndexes array in ascending order
374  // assumptions: 1. Most likely the quadratic terms are sorted already
375  // 2. The order of varTwoIndexes within varOneIndexes does not matter
376  int swapLoc;
377  int iswap;
378  double dswap;
379  for (int i=0; i< ncols-1; i++)
380  {
381  swapLoc = colStarts[i+1];
382  for (int j=colStarts[i]; j<colStarts[i+1]; j++)
383  {
384  if (qterms->varOneIndexes[j] != i)
385  {
386  while ( (qterms->varOneIndexes[swapLoc] != i) && (swapLoc < nq))
387  swapLoc++;
388  if (swapLoc < nq)
389  {
390  iswap = qterms->varOneIndexes[j];
391  qterms->varOneIndexes[j] = qterms->varOneIndexes[swapLoc];
392  qterms->varOneIndexes[swapLoc] = iswap;
393  iswap = qterms->varTwoIndexes[j];
394  qterms->varTwoIndexes[j] = qterms->varTwoIndexes[swapLoc];
395  qterms->varTwoIndexes[swapLoc] = iswap;
396  dswap = qterms->coefficients[j];
397  qterms->coefficients[j] = qterms->coefficients[swapLoc];
398  qterms->coefficients[swapLoc] = dswap;
399 #ifndef NDEBUG
400  outStr.str("");
401  outStr.clear();
402  outStr << "swapping locations " << j << " and " << swapLoc << std::endl;
403 
404  outStr << "after swap:" << std::endl;
405  outStr << " var One indexes:";
406  for (int i=0; i<nq; i++)
407  outStr << " " << qterms->varOneIndexes[i];
408  outStr << std::endl;
409  outStr << " var Two indexes:";
410  for (int i=0; i<nq; i++)
411  outStr << " " << qterms->varTwoIndexes[i];
412  outStr << std::endl;
413  outStr << " coefficients: ";
414  for (int i=0; i<nq; i++)
415  outStr << " " << qterms->coefficients[i];
416  outStr << std::endl;
418  ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
419 #endif
420  }
421  else
422  throw ErrorClass("Sorting of quadratic terms failed in OSCoinSolver");
423  }
424  }
425  }
426 #ifndef NDEBUG
427  outStr.str("");
428  outStr.clear();
429  outStr << "terminal arrays:" << std::endl;
430  outStr << " var One indexes:";
431  for (int i=0; i<nq; i++)
432  outStr << " " << qterms->varOneIndexes[i];
433  outStr << std::endl;
434  outStr << " var Two indexes:";
435  for (int i=0; i<nq; i++)
436  outStr << " " << qterms->varTwoIndexes[i];
437  outStr << std::endl;
438  outStr << " coefficients: ";
439  for (int i=0; i<nq; i++)
440  outStr << " " << qterms->coefficients[i];
441  outStr << std::endl;
443  ENUM_OUTPUT_LEVEL_trace, outStr.str());
444 #endif
445 
446  //osiSolver->loadQuadraticObjective(ncols, colStarts, qterms->varTwoIndexes, qterms->coefficients);
447  throw ErrorClass("Quadratic terms not implemented yet");
448  }
449  }
450 
452  }
453  catch(const ErrorClass& eclass)
454  {
455  osresult = new OSResult();
457  osresult->setGeneralStatusType( "error");
459  throw ErrorClass( osrl) ;
460  }
461 }//end buildSolverInstance()
462 
463 
464 
466 {
467  std::ostringstream outStr;
468 
469 #ifndef NDEBUG
470  osoutput->OSPrint(ENUM_OUTPUT_AREA_OSSolverInterfaces, ENUM_OUTPUT_LEVEL_debug, "build solver options\n");
471 #endif
472  this->bSetSolverOptions = true;
473  // the osi maps (NOTE: These are the only options supported by generic OsiSolverInterface)
474  // the OsiHintParameter Map
475  std::map<std::string, OsiHintParam> hintParamMap;
476  hintParamMap["OsiDoPresolveInInitial"] = OsiDoPresolveInInitial;
477  hintParamMap["OsiDoDualInInitial"] = OsiDoDualInInitial;
478  hintParamMap["OsiDoPresolveInResolve"] = OsiDoPresolveInResolve;
479  hintParamMap["OsiDoDualInResolve"] = OsiDoDualInResolve;
480  hintParamMap["OsiDoScale"] = OsiDoScale;
481  hintParamMap["OsiDoCrash"] = OsiDoCrash;
482  hintParamMap["OsiDoReducePrint"] = OsiDoReducePrint;
483  hintParamMap["OsiDoInBranchAndCut"] = OsiDoInBranchAndCut;
484  hintParamMap["OsiLastHintParam"] = OsiLastHintParam;
485  //
486  // the OsiHintStrength Map
487  std::map<std::string, OsiHintStrength> hintStrengthMap;
488  hintStrengthMap["OsiHintIgnore"] = OsiHintIgnore;
489  hintStrengthMap["OsiHintTry"] = OsiHintTry;
490  hintStrengthMap["OsiHintDo"] = OsiHintDo;
491  hintStrengthMap["OsiForceDo"] = OsiForceDo;
492  //
493  // the OsiStrParam Map
494  std::map<std::string, OsiStrParam> strParamMap;
495  strParamMap["OsiProbName"] = OsiProbName;
496  strParamMap["OsiSolverName"] = OsiSolverName;
497  strParamMap["OsiLastStrParam"] = OsiLastStrParam;
498  //
499  // the OsiDblParam Map
500  std::map<std::string, OsiDblParam> dblParamMap;
501  dblParamMap["OsiDualObjectiveLimit"] = OsiDualObjectiveLimit;
502  dblParamMap["OsiPrimalObjectiveLimit"] = OsiPrimalObjectiveLimit;
503  dblParamMap["OsiDualTolerance"] = OsiDualTolerance;
504  dblParamMap["OsiPrimalTolerance"] = OsiPrimalTolerance;
505  dblParamMap["OsiObjOffset"] = OsiObjOffset;
506  dblParamMap["OsiLastDblParam"] = OsiLastDblParam;
507  //
508  // the OsiIntParam Map
509  std::map<std::string, OsiIntParam> intParamMap;
510  intParamMap["OsiMaxNumIteration"] = OsiMaxNumIteration;
511  intParamMap["OsiMaxNumIterationHotStart"] = OsiMaxNumIterationHotStart;
512  intParamMap["OsiNameDiscipline"] = OsiNameDiscipline;
513  intParamMap["OsiLastIntParam"] = OsiLastIntParam;
514 
515  /*
516  * start default settings -- these get set
517  * even when the OSOption object is NULL
518  *
519  * */
520  OsiHintStrength hintStrength = OsiHintTry; //don't want too much output
521  osiSolver->setHintParam(OsiDoReducePrint, true, hintStrength);
522  // it looks like the COIN-OR default is to subtract off the constant rather than add it.
523  // this seems true regardless of max or min
524  osiSolver->setDblParam(OsiObjOffset, -osinstance->getObjectiveConstants()[0]);
525 
526  // Set SYMPHONY default print level
527 #ifdef COIN_HAS_SYMPHONY
528  if( sSolverName.find( "symphony") != std::string::npos)
529  {
530  OsiSymSolverInterface * si =
531  dynamic_cast<OsiSymSolverInterface *>(osiSolver) ;
532  si->setSymParam("verbosity", -2);
533  }
534 #endif //symphony end
535  /*
536  * end default settings
537  *
538  */
539 
540  // read option string if necessary
541  try
542  {
543  if(osoption == NULL && osol.length() > 0)
544  {
545  m_osolreader = new OSoLReader();
547  }
548 
549 // Process any options found
550  if(osoption != NULL)
551  {
552  int i;
553 
554 #ifndef NDEBUG
555  outStr.str("");
556  outStr.clear();
557  outStr << "number of solver options " << osoption->getNumberOfSolverOptions() << std::endl;
559 #endif
561  {
562  //this->bSetSolverOptions = true;
563  std::vector<SolverOption*> optionsVector;
564 
565  //get the osi options, which apply to all solvers
566  optionsVector = osoption->getSolverOptions( "osi",true);
567  int num_osi_options = optionsVector.size();
568  char *pEnd;
569  bool yesNo;
570 
575  for(i = 0; i < num_osi_options; i++)
576  {
577 #ifndef NDEBUG
578  outStr.str("");
579  outStr.clear();
580  outStr << "osi solver option " << optionsVector[ i]->name << std::endl;
581  outStr << "osi solver value " << optionsVector[ i]->value << std::endl;
583  ENUM_OUTPUT_LEVEL_trace, outStr.str());
584 #endif
585  if (optionsVector[ i]->type == "OsiHintStrength" )
586  {
587  if( hintStrengthMap.find( optionsVector[ i]->name ) != hintStrengthMap.end() )
588  {
589  hintStrength = hintStrengthMap[ optionsVector[ i]->name] ;
590  }
591  }
592  }
593 
597  for(i = 0; i < num_osi_options; i++)
598  {
599 #ifndef NDEBUG
600  outStr.str("");
601  outStr.clear();
602  outStr << "osi solver option " << optionsVector[ i]->name << std::endl;
603  outStr << "osi solver value " << optionsVector[ i]->value << std::endl;
605  ENUM_OUTPUT_LEVEL_trace, outStr.str());
606 #endif
607  if (optionsVector[ i]->type == "OsiHintParam" )
608  {
609  if( optionsVector[ i]->value == "true" )
610  {
611  yesNo = true;
612  }
613  else
614  {
615  yesNo = false;
616  }
617  if( hintParamMap.find( optionsVector[ i]->name ) != hintParamMap.end() )
618  {
619  osiSolver->setHintParam( hintParamMap[ optionsVector[ i]->name] , yesNo, hintStrength);
620  }
621  }
622  else if(optionsVector[ i]->type == "OsiStrParam" )
623  {
624  if( strParamMap.find( optionsVector[ i]->name ) != strParamMap.end() )
625  {
626  osiSolver->setStrParam( strParamMap[ optionsVector[ i]->name] , optionsVector[ i]->value);
627  }
628  }
629  else if(optionsVector[ i]->type == "OsiDblParam" )
630  {
631  if( dblParamMap.find( optionsVector[ i]->name ) != dblParamMap.end() )
632  {
633  osiSolver->setDblParam( dblParamMap[ optionsVector[ i]->name] , os_strtod( optionsVector[ i]->value.c_str(), &pEnd ));
634  }
635 
636  }
637  else if(optionsVector[ i]->type == "OsiIntParam" )
638  {
639  if( intParamMap.find( optionsVector[ i]->name ) != intParamMap.end() )
640  {
641  osiSolver->setIntParam( intParamMap[ optionsVector[ i]->name] , atoi( optionsVector[ i]->value.c_str() ) );
642  }
643  }
644  else if (optionsVector[ i]->type == "bool" )
645  {
646  if( optionsVector[ i]->name == "primalSimplex" )
647  {
648  if (optionsVector[ i]->value != "false")
649  osiSolver->enableSimplexInterface((optionsVector[ i]->value != "false"));
650  }
651  }
652  }
653 
654  // Next get all options that are specific to one solver
655 
656  if( sSolverName.find( "cbc") != std::string::npos)
657  {
658  // get Cbc options and create a command line for CbcMain1()
659  if(optionsVector.size() > 0) optionsVector.clear();
660  optionsVector = osoption->getSolverOptions( "cbc",true);
661 
662  int num_cbc_options = optionsVector.size();
663  char *cstr;
664  std::string cbc_option;
665  num_cbc_argv = optionsVector.size() + 3;
666  cbc_argv = new const char*[ num_cbc_argv];
667 
668  // the first option
669  cbc_option = "OS";
670  cstr = new char [cbc_option.size() + 1];
671  strcpy (cstr, cbc_option.c_str());
672  cbc_argv[ 0] = cstr;
673 
674  for(i = 0; i < num_cbc_options; i++)
675  {
676 #ifndef NDEBUG
677  outStr.str("");
678  outStr.clear();
679  outStr << "cbc solver option " << optionsVector[ i]->name << std::endl;
680  outStr << "cbc solver value " << optionsVector[ i]->name << std::endl;
682  ENUM_OUTPUT_LEVEL_debug, outStr.str());
683 #endif
684 
685  if(optionsVector[ i]->value.length() > 0 )
686  {
687  cbc_option = "-" + optionsVector[ i]->name +"="+optionsVector[ i]->value;
688  }
689  else
690  {
691  cbc_option = "-" + optionsVector[ i]->name ;
692  }
693  cstr = new char [cbc_option.size() + 1];
694  strcpy (cstr, cbc_option.c_str());
695  cbc_argv[i + 1] = cstr;
696  }
697 
698  // the solve option
699  cbc_option = "-solve";
700  cstr = new char [cbc_option.size() + 1];
701  strcpy (cstr, cbc_option.c_str());
702  cbc_argv[ num_cbc_argv - 2] = cstr;
703 
704  // the quit option
705  cbc_option = "-quit";
706  cstr = new char [cbc_option.size() + 1];
707  strcpy (cstr, cbc_option.c_str());
708  cbc_argv[ num_cbc_argv - 1] = cstr;
709 
710  }//end of cbc if
711 
712  // Here we look for options specific to Clp. Use the Cbc interface if there are any
713 
714  else if( sSolverName.find( "clp") != std::string::npos)
715  {
716  // get Clp options and create a command line for CbcMain1()
717  if(optionsVector.size() > 0) optionsVector.clear();
718  optionsVector = osoption->getSolverOptions( "clp",true);
719 
720  int num_cbc_options = optionsVector.size();
721  if (num_cbc_options > 0)
722  {
723  char *cstr;
724  std::string cbc_option;
725  num_cbc_argv = optionsVector.size() + 3;
726  cbc_argv = new const char*[ num_cbc_argv];
727 
728  // the first option
729  cbc_option = "OS";
730  cstr = new char [cbc_option.size() + 1];
731  strcpy (cstr, cbc_option.c_str());
732  cbc_argv[ 0] = cstr;
733 
734  for(i = 0; i < num_cbc_options; i++)
735  {
736 #ifndef NDEBUG
737  outStr.str("");
738  outStr.clear();
739  outStr << "clp solver option " << optionsVector[ i]->name << std::endl;
740  outStr << "clp solver value " << optionsVector[ i]->name << std::endl;
742  ENUM_OUTPUT_LEVEL_debug, outStr.str());
743 #endif
744 
745  if(optionsVector[ i]->value.length() > 0 )
746  {
747  cbc_option = "-" + optionsVector[ i]->name +"="+optionsVector[ i]->value;
748  }
749  else
750  {
751  cbc_option = "-" + optionsVector[ i]->name ;
752  }
753  cstr = new char [cbc_option.size() + 1];
754  strcpy (cstr, cbc_option.c_str());
755  cbc_argv[i + 1] = cstr;
756  }
757 
758  // the solve option
759  cbc_option = "-solve";
760  cstr = new char [cbc_option.size() + 1];
761  strcpy (cstr, cbc_option.c_str());
762  cbc_argv[ num_cbc_argv - 2] = cstr;
763 
764  // the quit option
765  cbc_option = "-quit";
766  cstr = new char [cbc_option.size() + 1];
767  strcpy (cstr, cbc_option.c_str());
768  cbc_argv[ num_cbc_argv - 1] = cstr;
769  }
770  }
771 
772  // Options for SYMPHONY
773 
774  else if( sSolverName.find( "symphony") != std::string::npos)
775  {
776 #ifdef COIN_HAS_SYMPHONY
777  if(optionsVector.size() > 0) optionsVector.clear();
778  //first the number of processors -- applies only to SYMPHONY
779  OsiSymSolverInterface * si =
780  dynamic_cast<OsiSymSolverInterface *>(osiSolver) ;
781 
782  optionsVector = osoption->getSolverOptions( "symphony",true);
783  int num_sym_options = optionsVector.size();
784  for(i = 0; i < num_sym_options; i++)
785  {
786 #ifndef NDEBUG
787  outStr.str("");
788  outStr.clear();
789  outStr << "symphony solver option " << optionsVector[ i]->name << std::endl;
790  outStr << "symphony solver value " << optionsVector[ i]->name << std::endl;
792 #endif
793  if (optionsVector[ i]->type == "OsiStrParam" || optionsVector[ i]->type == "string")
794  {
795  if (!si->setSymParam(optionsVector[ i]->name, optionsVector[ i]->value))
796  throw ErrorClass ("Failed to set Symphony solver option "+optionsVector[ i]->name);
797  }
798  else if (optionsVector[ i]->type == "OsiDblParam" || optionsVector[ i]->type == "double")
799  {
800  if (!si->setSymParam(optionsVector[ i]->name, os_strtod( optionsVector[ i]->value.c_str(), &pEnd )))
801  throw ErrorClass ("Failed to set Symphony solver option "+optionsVector[ i]->name);
802  }
803  else if (optionsVector[ i]->type == "OsiIntParam" || optionsVector[ i]->type == "integer")
804  {
805  if (!si->setSymParam(optionsVector[ i]->name, atoi( optionsVector[ i]->value.c_str() ) ))
806  throw ErrorClass ("Failed to set Symphony solver option "+optionsVector[ i]->name);
807  }
808  }
809 #endif //symphony end
810  }
811  }
812 
813  //now set initial values
814  int n,m,k;
815  if (osoption != NULL)
817  else
818  m = 0;
819 #ifndef NDEBUG
820  outStr.str("");
821  outStr.clear();
822  outStr << "number of variables initialed: " << m << std::endl;
824 #endif
825 
826  if (m > 0)
827  {
828 #ifndef NDEBUG
829  osoutput->OSPrint(ENUM_OUTPUT_AREA_OSSolverInterfaces, ENUM_OUTPUT_LEVEL_debug, "get initial values\n");
830 #endif
832  double* denseInitVarVector;
833  denseInitVarVector = new double[n];
834  bool* initialed;
835  initialed = new bool[n];
836 
837  for(k = 0; k < n; k++)
838  initialed[k] = false;
839 
840  InitVarValue** initVarVector = osoption->getInitVarValuesSparse();
841 #ifndef NDEBUG
843 #endif
844 
845  double initval;
846  for(k = 0; k < m; k++)
847  {
848  i = initVarVector[k]->idx;
849  if (initVarVector[k]->idx >= n)
850  throw ErrorClass ("Illegal index value in variable initialization");
851 
852  initval = initVarVector[k]->value;
854  {
855  if (osinstance->instanceData->variables->var[k]->lb > initval)
856  throw ErrorClass ("Initial value outside of bounds");
857  }
858  else if (osinstance->instanceData->variables->var[k]->lb == -OSDBL_MAX)
859  {
860  if (osinstance->instanceData->variables->var[k]->ub < initval)
861  throw ErrorClass ("Initial value outside of bounds");
862  }
863  else
864  {
865  if ((osinstance->instanceData->variables->var[k]->lb > initval) ||
866  (osinstance->instanceData->variables->var[k]->ub < initval))
867  throw ErrorClass ("Initial value outside of bounds");
868  }
869 
870  denseInitVarVector[initVarVector[k]->idx] = initval;
871  initialed[initVarVector[k]->idx] = true;
872  }
873 
874  double default_initval;
875  default_initval = 0.0;
876 
877  for(k = 0; k < n; k++)
878  {
879  if (!initialed[k])
880  {
882  if (osinstance->instanceData->variables->var[k]->lb <= default_initval)
883  denseInitVarVector[k] = default_initval;
884  else
885  denseInitVarVector[k] = osinstance->instanceData->variables->var[k]->lb;
886  else if (osinstance->instanceData->variables->var[k]->lb == -OSDBL_MAX)
887  if (osinstance->instanceData->variables->var[k]->ub >= default_initval)
888  denseInitVarVector[k] = default_initval;
889  else
890  denseInitVarVector[k] = osinstance->instanceData->variables->var[k]->ub;
891  else if ((osinstance->instanceData->variables->var[k]->lb <= default_initval) &&
892  (osinstance->instanceData->variables->var[k]->ub >= default_initval))
893  denseInitVarVector[k] = default_initval;
894  else if (osinstance->instanceData->variables->var[k]->lb > default_initval)
895  denseInitVarVector[k] = osinstance->instanceData->variables->var[k]->lb;
896  else
897  denseInitVarVector[k] = osinstance->instanceData->variables->var[k]->ub;
898  }
899 // denseInitVarVector[k] = default_initval;
900 // denseInitVarVector[k] = osinstance->instanceData->variables->var[k]->lb;
901  }
902 #ifndef NDEBUG
903  outStr.str("");
904  outStr.clear();
905  outStr << "set initial values: " << std::endl;
906  for (k=0; k < n; k++)
907  outStr << " " << k << ": " << denseInitVarVector[k] << std::endl;
909 #endif
910  osiSolver->setColSolution( denseInitVarVector);
911  delete[] denseInitVarVector;
912  delete[] initialed;
913 #ifndef NDEBUG
915 #endif
916 
917  } // end set initial variable values
918 
919 
920  // add starting basis --- only supported by Clp
921 
922 // if (sSolverName == "clp" || sSolverName == "cbc")
923  {
924  if ( osoption != NULL &&
925  osoption->optimization != NULL &&
926  ((osoption->optimization->variables != NULL &&
928  (osoption->optimization->constraints != NULL &&
930 
931  /* Only the following statuses are recognized:
932  *
933  * enum Status {
934  * isFree = 0x00, ///< Nonbasic free variable
935  * basic = 0x01, ///< Basic variable
936  * atUpperBound = 0x02, ///< Nonbasic at upper bound
937  * atLowerBound = 0x03 ///< Nonbasic at lower bound
938  * }
939  *
940  * Any others, or any missing statuses, are set to isFree; let Clp deal with it.
941  */
942  {
943  int nsBas,naBas,nsUpp,naUpp,nsLow,naLow,nvar,ncon;
944  int* tmpBas = NULL;
945  CoinWarmStartBasis* warmstart = new CoinWarmStartBasis();
946  nvar = osinstance->getVariableNumber();
948  warmstart->setSize(nvar, ncon); // this initials everything to isFree
949 
950  // pull the number of basis elements of each type
951  if ( osoption->optimization->variables != NULL &&
953  {
957  }
958  else
959  {
960  nsBas = 0;
961  nsUpp = 0;
962  nsLow = 0;
963  }
964  if ( osoption->optimization->constraints != NULL &&
966  {
970  }
971  else
972  {
973  naBas = 0;
974  naUpp = 0;
975  naLow = 0;
976  }
977 
978  // get the elements and store them into the Clp warm start object
979  if (nsBas > 0)
980  {
981  tmpBas = new int[nsBas];
983  for (int i=0; i<nsBas; i++)
984  warmstart->setStructStatus(tmpBas[i], (CoinWarmStartBasis::Status)0x01);
985  delete [] tmpBas;
986  }
987  if (naBas > 0)
988  {
989  tmpBas = new int[naBas];
991  for (int i=0; i<naBas; i++)
992  warmstart->setArtifStatus(tmpBas[i], (CoinWarmStartBasis::Status)0x01);
993  delete [] tmpBas;
994  }
995 
996  if (nsUpp > 0)
997  {
998  tmpBas = new int[nsUpp];
1000  for (int i=0; i<nsUpp; i++)
1001  warmstart->setStructStatus(tmpBas[i], (CoinWarmStartBasis::Status)0x02);
1002  delete [] tmpBas;
1003  }
1004  if (naUpp > 0)
1005  {
1006  tmpBas = new int[naUpp];
1008  for (int i=0; i<naUpp; i++)
1009  warmstart->setArtifStatus(tmpBas[i], (CoinWarmStartBasis::Status)0x02);
1010  delete [] tmpBas;
1011  }
1012 
1013  if (nsLow > 0)
1014  {
1015  tmpBas = new int[nsLow];
1017  for (int i=0; i<nsLow; i++)
1018  warmstart->setStructStatus(tmpBas[i], (CoinWarmStartBasis::Status)0x03);
1019  delete [] tmpBas;
1020  }
1021  if (naLow > 0)
1022  {
1023  tmpBas = new int[naLow];
1025  for (int i=0; i<naLow; i++)
1026  warmstart->setArtifStatus(tmpBas[i], (CoinWarmStartBasis::Status)0x03);
1027  delete [] tmpBas;
1028  }
1029 
1030  osiSolver->setWarmStart(warmstart);
1031 
1032  } // end if (some basis info available)
1033  } // end if solver = clp
1034 
1035  }// end of osoption if
1036 
1037 #ifndef NDEBUG
1038  osoutput->OSPrint(ENUM_OUTPUT_AREA_OSSolverInterfaces, ENUM_OUTPUT_LEVEL_debug, "solver options set\n");
1039 #endif
1040  }//end of try
1041 
1042  catch(const ErrorClass& eclass)
1043  {
1044  osoutput->OSPrint(ENUM_OUTPUT_AREA_OSSolverInterfaces, ENUM_OUTPUT_LEVEL_error, "THERE IS AN ERROR\n");
1045  osresult = new OSResult();
1047  osresult->setGeneralStatusType( "error");
1049  throw ErrorClass( osrl) ;
1050  }
1051 }//end setSolverOptions()
1052 
1053 
1055 {
1056  bool columnMajor = osinstance->getLinearConstraintCoefficientMajor();
1057  try
1058  {
1059  double maxGap = 0;
1061  {
1062  m_CoinPackedMatrix = new CoinPackedMatrix(
1063  columnMajor, //Column or Row Major
1064  columnMajor? osinstance->getConstraintNumber() : osinstance->getVariableNumber(), //Minor Dimension
1065  columnMajor? osinstance->getVariableNumber() : osinstance->getConstraintNumber(), //Major Dimension
1066  osinstance->getLinearConstraintCoefficientNumber(), //Number of nonzeroes
1068  columnMajor? osinstance->getLinearConstraintCoefficientsInColumnMajor()->indexes : osinstance->getLinearConstraintCoefficientsInRowMajor()->indexes, //Pointer to start of minor dimension indexes -- change to allow for row storage
1070  0, 0, maxGap );
1071  }
1072  else
1073  {
1074  int* start = new int[osinstance->getVariableNumber()+1];
1075  for (int i=0; i <= osinstance->getVariableNumber(); i++)
1076  start[i] = 0;
1077  m_CoinPackedMatrix = new CoinPackedMatrix(
1078  columnMajor, //Column or Row Major
1079  columnMajor? osinstance->getConstraintNumber() : osinstance->getVariableNumber(), //Minor Dimension
1080  columnMajor? osinstance->getVariableNumber() : osinstance->getConstraintNumber(), //Major Dimension
1081  osinstance->getLinearConstraintCoefficientNumber(), //Number of nonzeroes
1082  NULL, //Pointer to matrix nonzeroes
1083  NULL, //Pointer to start of minor dimension indexes -- change to allow for row storage
1084  start, //Pointers to start of columns.
1085  NULL, 0.0, maxGap );
1086  }
1087 
1088 
1089  return true;
1090  }
1091  catch(const ErrorClass& eclass)
1092  {
1093  osresult = new OSResult();
1095  osresult->setGeneralStatusType( "error");
1097  throw ErrorClass( osrl) ;
1098  }
1099 } // end setCoinPackedMatrix
1100 
1102 {
1103  std::ostringstream outStr;
1104  if(osresult != NULL) delete osresult;
1105  osresult = new OSResult();
1106  try
1107  {
1108  // make sure the solver instance exists
1109  if( this->bCallbuildSolverInstance == false) buildSolverInstance();
1110  //set the options
1111  if( this->bSetSolverOptions == false) setSolverOptions();
1112  }
1113  catch(const ErrorClass& eclass)
1114  {
1115  throw ErrorClass( osrl) ;
1116  }
1117 
1118  // resultHeader information
1119  if(osresult->setSolverInvoked("COIN-OR " + sSolverName) != true)
1120  throw ErrorClass("OSResult error: SetSolverInvoked");
1122  throw ErrorClass("OSResult error: setInstanceName");
1123  //if(osresult->setJobID( osresultdata->jobID) != true)
1124  // throw ErrorClass("OSResult error: setJobID");
1125  //if(osresult->setGeneralMessage( osresultdata->message) != true)
1126  // throw ErrorClass("OSResult error: setGeneralMessage");
1127  // set basic problem parameters
1128 
1130  throw ErrorClass("OSResult error: setVariableNumer");
1131  if(osresult->setObjectiveNumber( 1) != true)
1132  throw ErrorClass("OSResult error: setObjectiveNumber");
1134  throw ErrorClass("OSResult error: setConstraintNumber");
1135  if(osresult->setSolutionNumber( 1) != true)
1136  throw ErrorClass("OSResult error: setSolutionNumer");
1137 
1138  //
1139  try
1140  {
1141  double start = CoinCpuTime();
1142  try
1143  {
1144  if( (sSolverName.find( "cbc") != std::string::npos) ||
1145  ((sSolverName.find( "clp") != std::string::npos) && num_cbc_argv > 0) )
1146  {
1147  // just use simple branch and bound for anything but cbc
1148  CbcModel model( *osiSolver);
1149 
1150  CbcMain0( model);
1151 
1152  // make sure we define cbc_argv if not done already when reading options
1153  if(num_cbc_argv <= 0)
1154  {
1155  char *cstr;
1156  std::string cbc_option;
1157  num_cbc_argv = 4;
1158  cbc_argv = new const char*[ num_cbc_argv];
1159 
1160  // the first option
1161  cbc_option = "OS";
1162  cstr = new char [cbc_option.size() + 1];
1163  strcpy (cstr, cbc_option.c_str());
1164  cbc_argv[ 0] = cstr;
1165 
1166  // the log option -- by default minimal printing
1167  cbc_option = "-log=0";
1168  cstr = new char [cbc_option.size() + 1];
1169  strcpy (cstr, cbc_option.c_str());
1170  cbc_argv[ 1] = cstr;
1171 
1172  // the solve option
1173  cbc_option = "-solve";
1174  cstr = new char [cbc_option.size() + 1];
1175  strcpy (cstr, cbc_option.c_str());
1176  cbc_argv[ 2] = cstr;
1177 
1178  // the quit option
1179  cbc_option = "-quit";
1180  cstr = new char [cbc_option.size() + 1];
1181  strcpy (cstr, cbc_option.c_str());
1182  cbc_argv[ 3] = cstr;
1183  }
1184  int i;
1185 
1187  ENUM_OUTPUT_LEVEL_info, "CALLING THE CBC SOLVER CBCMAIN1()\n");
1188 #ifndef NDEBUG
1189  outStr.str("");
1190  outStr.clear();
1191  for(i = 0; i < num_cbc_argv; i++)
1192  {
1193  outStr << sSolverName << " option: " << cbc_argv[ i] << std::endl;
1194  }
1196 #endif
1197  CbcMain1( num_cbc_argv, cbc_argv, model);
1198 
1199  //do the garbage collection on cbc_argv
1200  for(i = 0; i < num_cbc_argv; i++)
1201  {
1202  delete[] cbc_argv[ i];
1203  cbc_argv[i] = NULL;
1204  }
1205  if( num_cbc_argv > 0)
1206  {
1207  delete[] cbc_argv;
1208  cbc_argv = NULL;
1209  num_cbc_argv = 0;
1210  }
1211 
1212  cpuTime = CoinCpuTime() - start;
1213 
1214  // create a solver
1215  OsiSolverInterface *solver = model.solver();
1217  {
1218  writeResult( &model);
1219  }
1220  else
1221  {
1222  writeResult( solver);
1223  }
1224  }
1225  else // use other solvers
1226  {
1227  //if an LP just do initial solve
1229  {
1230  osiSolver->branchAndBound();
1231  }
1232  else
1233  {
1234  osiSolver->initialSolve();
1235  }
1236  cpuTime = CoinCpuTime() - start;
1237 
1239  }
1240  }
1241 
1242  catch(CoinError& e)
1243  {
1244  std::string errmsg;
1245  errmsg = "Coin Solver Error: " + e.message() + "\n" + " see method "
1246  + e.methodName() + " in class " + e.className();
1247  throw ErrorClass( errmsg );
1248  }
1249  }
1250 
1251  catch(const ErrorClass& eclass)
1252  {
1253  std::string::size_type pos1 = eclass.errormsg.find( "<osrl");
1254  if(pos1 == std::string::npos)
1255  {
1257  osresult->setGeneralStatusType("error");
1259  }
1260  else
1261  {
1262  osrl = eclass.errormsg;
1263  }
1264  throw ErrorClass( osrl);
1265  }
1266 } // end solve
1267 
1268 std::string CoinSolver::getCoinSolverType(std::string lcl_osol)
1269 {
1270 // this is deprecated, but keep it around
1271  try
1272  {
1273  if( lcl_osol.find( "clp") != std::string::npos)
1274  {
1275  return "coin_solver_glpk";
1276  }
1277  else
1278  {
1279  if( lcl_osol.find( "cbc") != std::string::npos)
1280  {
1281  return "coin_solver_cpx";
1282  }
1283  else
1284  {
1285  if( lcl_osol.find( "cpx") != std::string::npos)
1286  {
1287  return "coin_solver_clp";
1288  }
1289  else
1290  {
1291  if(lcl_osol.find( "glpk") != std::string::npos)
1292  {
1293  return "";
1294  }
1295  else throw ErrorClass("a supported solver was not defined");
1296  }
1297  }
1298  }
1299  }
1300  catch(const ErrorClass& eclass)
1301  {
1303  osresult->setGeneralStatusType( "error");
1305  throw ErrorClass( osrl) ;
1306  }
1307 } // end getCoinSolverType
1308 
1309 #ifndef NDEBUG
1311 {
1312  int i;
1313  // print out problem parameters
1314  cout << "This is problem: " << osinstance->getInstanceName() << endl;
1315  cout << "The problem source is: " << osinstance->getInstanceSource() << endl;
1316  cout << "The problem description is: " << osinstance->getInstanceDescription() << endl;
1317  cout << "number of variables = " << osinstance->getVariableNumber() << endl;
1318  cout << "number of Rows = " << osinstance->getConstraintNumber() << endl;
1319 
1320  // print out the variable information
1321  if(osinstance->getVariableNumber() > 0)
1322  {
1323  for(i = 0; i < osinstance->getVariableNumber(); i++)
1324  {
1325  if(osinstance->getVariableNames() != NULL) cout << "variable Names " << osinstance->getVariableNames()[ i] << endl;
1326  if(osinstance->getVariableTypes() != NULL) cout << "variable Types " << osinstance->getVariableTypes()[ i] << endl;
1327  if(osinstance->getVariableLowerBounds() != NULL) cout << "variable Lower Bounds " << osinstance->getVariableLowerBounds()[ i] << endl;
1328  if(osinstance->getVariableUpperBounds() != NULL) cout << "variable Upper Bounds " << osinstance->getVariableUpperBounds()[i] << endl;
1329  }
1330  }
1331 
1332  // print out objective function information
1334  {
1335  if( osinstance->getObjectiveMaxOrMins()[0] == "min") cout << "problem is a minimization" << endl;
1336  else cout << "problem is a maximization" << endl;
1337  for(i = 0; i < osinstance->getVariableNumber(); i++)
1338  {
1339  cout << "OBJ COEFFICIENT = " << osinstance->getDenseObjectiveCoefficients()[0][i] << endl;
1340  }
1341  }
1342  // print out constraint information
1343  if(osinstance->getConstraintNumber() > 0)
1344  {
1345  for(i = 0; i < osinstance->getConstraintNumber(); i++)
1346  {
1347  if(osinstance->getConstraintNames() != NULL) cout << "row name = " << osinstance->getConstraintNames()[i] << endl;
1348  if(osinstance->getConstraintLowerBounds() != NULL) cout << "row lower bound = " << osinstance->getConstraintLowerBounds()[i] << endl;
1349  if(osinstance->getConstraintUpperBounds() != NULL) cout << "row upper bound = " << osinstance->getConstraintUpperBounds()[i] << endl;
1350  }
1351  }
1352 
1353  // print out linear constraint data
1354  if(m_CoinPackedMatrix != NULL) m_CoinPackedMatrix->dumpMatrix();
1355 } // end dataEchoCheck
1356 #endif
1357 
1358 
1359 void CoinSolver::writeResult(OsiSolverInterface *solver)
1360 {
1361  double *x = NULL;
1362  double *y = NULL;
1363  double *z = NULL;
1364  int *cbasis = NULL; //column basis information
1365  int *rbasis = NULL; //row basis information
1366  int *idx = NULL;
1367  int kount;
1368 
1369  //vectors to hold the basis information
1370  std::vector<int> freeVars;
1371  std::vector<int> basicVars;
1372  std::vector<int> nonBasicLower;
1373  std::vector<int> nonBasicUpper;
1374  std::vector<int>::iterator vit;
1375  int **basisIdx;
1376  basisIdx = new int*[ 4];
1377  //end of vectors
1378 
1379  int numberOfVar = solver->getNumCols();
1380  int numberOfCon = solver->getNumRows();
1382  std::string *rcost = NULL;
1383  if ( numberOfVar > 0 ) x = new double[numberOfVar];
1384  if ( numberOfCon > 0 ) y = new double[numberOfCon ];
1385  if ( numberOfVar > 0 ) idx = new int[ numberOfVar];
1386  if ( numberOfVar > 0 ) rcost = new std::string[numberOfVar];
1387  z = new double[1];
1388 
1389  //allocate basis if solver supports it (Clp, Cbc, Cplex, Gurobi
1390  bool supportsBasis = false;
1391  if ( (sSolverName.find( "clp") != std::string::npos)
1392  || (sSolverName.find( "cbc") != std::string::npos)
1393  || (sSolverName.find( "cplex") != std::string::npos)
1394  || (sSolverName.find( "gurobi") != std::string::npos) )
1395  {
1396  if (numOfIntVars == 0) // basis information is meaningless for (M)IP
1397  {
1398  if (numberOfVar > 0) cbasis = new int[numberOfVar];
1399  if (numberOfCon > 0) rbasis = new int[numberOfCon];
1400  supportsBasis = true;
1401  }
1402  }
1403 
1404  int solIdx = 0;
1405  int i = 0;
1406  int numberOfOtherVariableResults = 1;
1407  int otherIdx = 0;
1408  std::string description = "";
1409 
1410  try
1411  {
1412  osresult->setGeneralStatusType("normal");
1415  osresult->setSolverInvoked( "COIN-OR " + sSolverName );
1416  if (solver->isProvenOptimal() == true)
1417  {
1418  osresult->setSolutionStatus(solIdx, "optimal", description);
1419  if ( supportsBasis )
1420  {
1421  solver->getBasisStatus( cbasis, rbasis);
1422  }
1423 
1424  }//end if proven optimal
1425  else // some other terminating condition
1426  {
1427  if(solver->isProvenPrimalInfeasible() == true)
1428  osresult->setSolutionStatus(solIdx, "infeasible", "the problem is primal infeasible");
1429  else
1430  {
1431  if(solver->isProvenDualInfeasible() == true)
1432  osresult->setSolutionStatus(solIdx, "unbounded", "the problem is unbounded");
1433  else
1434  {
1435  if(solver->isPrimalObjectiveLimitReached() == true)
1436  {
1437  osresult->setSolutionStatus(solIdx, "other", "primal objective limit reached");
1438  if ( supportsBasis )
1439  {
1440  solver->getBasisStatus( cbasis, rbasis);
1441  }
1442  }
1443  else
1444  {
1445  if(solver->isDualObjectiveLimitReached() == true)
1446  {
1447  osresult->setSolutionStatus(solIdx, "other", "dual objective limit reached");
1448  if ( supportsBasis )
1449  {
1450  solver->getBasisStatus( cbasis, rbasis);
1451  }
1452  }
1453  else
1454  {
1455  if(solver->isIterationLimitReached() == true)
1456  {
1457  osresult->setSolutionStatus(solIdx, "other", "iteration limit reached");
1458  if ( supportsBasis )
1459  {
1460  solver->getBasisStatus( cbasis, rbasis);
1461  }
1462  }
1463  else
1464  {
1465  if(solver->isAbandoned() == true)
1466  osresult->setSolutionStatus(solIdx, "other", "there are numerical difficulties");
1467  else
1468  if( solver->getNumCols() == 0) osresult->setSolutionMessage(solIdx, "Warning: this problem has zero decision variables!");
1469  else
1470  osresult->setSolutionStatus(solIdx, "other", description);
1471  }
1472  }
1473  }
1474  }
1475  }
1476  }
1477 
1478  /* Retrieve the solution */
1479  //
1480  *(z + 0) = solver->getObjValue();
1481 
1482  osresult->setObjectiveValuesDense(solIdx, z);
1483 
1484  for(i=0; i < numberOfVar; i++)
1485  {
1486  *(x + i) = solver->getColSolution()[i];
1487  *(idx + i) = i;
1488 
1489  // sort basis information for variables into four categories
1490  if( (cbasis != NULL) && (solver->isProvenOptimal() == true) )
1491  {
1492  switch (cbasis[ i] )
1493  {
1494  case 0:
1495  {
1496  //a free variable
1497  freeVars.push_back( i);
1498  break;
1499  }
1500 
1501  case 1:
1502  {
1503  //a basic variable
1504  basicVars.push_back( i);
1505  break;
1506  }
1507 
1508  case 2:
1509  {
1510  //nonbasic at upper bound
1511  nonBasicUpper.push_back( i );
1512  break;
1513  }
1514 
1515  case 3:
1516  {
1517  //nonbasic at lower bound
1518  nonBasicLower.push_back( i) ;
1519  break;
1520  }
1521  default:
1522  throw ErrorClass("unknown result from Osi getBasisStatus when getting variable basis status");
1523 
1524  }//end switch
1525 
1526  } //end if on cbasis == NULL
1527 
1528  }// end for on number of variables
1529 
1530  //now store basis information for variables
1531  if(freeVars.size() > 0)
1532  {
1533  kount = 0;
1534 
1535 
1536  basisIdx[ 0] = new int[ freeVars.size()];
1537 
1538  for(vit = freeVars.begin(); vit < freeVars.end(); vit++)
1539  {
1540  basisIdx[0][ kount++] = *vit;
1541  }
1542 
1544  delete[] basisIdx[ 0];
1545  freeVars.clear();
1546  }
1547 
1548  if(basicVars.size() > 0)
1549  {
1550  kount = 0;
1551 
1552  basisIdx[ 1] = new int[ basicVars.size()];
1553 
1554  for(vit = basicVars.begin(); vit < basicVars.end(); vit++)
1555  {
1556  basisIdx[1][ kount++] = *vit;
1557  }
1558 
1560  delete[] basisIdx[ 1];
1561  basicVars.clear();
1562  }
1563 
1564  if(nonBasicUpper.size() > 0)
1565  {
1566  kount = 0;
1567 
1568  basisIdx[ 2] = new int[ nonBasicUpper.size()];
1569 
1570  for(vit = nonBasicUpper.begin(); vit < nonBasicUpper.end(); vit++)
1571  {
1572  basisIdx[2][ kount++] = *vit;
1573  }
1574 
1576  delete[] basisIdx[ 2];
1577  nonBasicUpper.clear();
1578  }
1579 
1580 
1581  if(nonBasicLower.size() > 0)
1582  {
1583  kount = 0;
1584 
1585  basisIdx[ 3] = new int[ nonBasicLower.size()];
1586 
1587  for(vit = nonBasicLower.begin(); vit < nonBasicLower.end(); vit++)
1588  {
1589  basisIdx[3][ kount++] = *vit;
1590  }
1591 
1593  delete[] basisIdx[ 3];
1594  nonBasicLower.clear();
1595  }
1596  //end get basis information for variables
1597 
1599  // Symphony does not get dual prices
1600  if( sSolverName.find( "symphony") == std::string::npos && osinstance->getNumberOfIntegerVariables() == 0 && osinstance->getNumberOfBinaryVariables() == 0)
1601  {
1602  for(i = 0; i < numberOfCon; i++)
1603  {
1604  *(y + i) = solver->getRowPrice()[ i];
1605 
1606  // get basis information
1607  if((rbasis != NULL) && (solver->isProvenOptimal() == true) )
1608  {
1609  switch (rbasis[ i] )
1610  {
1611  case 0:
1612  {
1613  //a free variable
1614  freeVars.push_back( i);
1615  break;
1616  }
1617 
1618  case 1:
1619  {
1620  //a basic variable
1621  basicVars.push_back( i);
1622  break;
1623  }
1624 
1625  case 2:
1626  {
1627  //nonbasic at upper bound
1628  nonBasicUpper.push_back( i );
1629  break;
1630  }
1631 
1632  case 3:
1633  {
1634  //nonbasic at lower bound
1635  nonBasicLower.push_back( i) ;
1636  break;
1637  }
1638  default:
1639  throw ErrorClass("unknown result from Osi getBasisStatus when getting row basis status");
1640 
1641  }//end switch
1642 
1643  } //end if on rbasis == NULL
1644 
1645 
1646  }// end for of loop on constraints
1647 
1649 
1650 
1651  //now set basis information for variables
1652  if(freeVars.size() > 0)
1653  {
1654  kount = 0;
1655 
1656  basisIdx[ 0] = new int[ freeVars.size()];
1657 
1658  for(vit = freeVars.begin(); vit < freeVars.end(); vit++)
1659  {
1660  basisIdx[0][ kount++] = *vit;
1661  }
1662 
1664  delete[] basisIdx[ 0];
1665  freeVars.clear();
1666  }
1667 
1668  if(basicVars.size() > 0)
1669  {
1670  kount = 0;
1671 
1672  basisIdx[ 1] = new int[ basicVars.size()];
1673 
1674  for(vit = basicVars.begin(); vit < basicVars.end(); vit++)
1675  {
1676  basisIdx[1][ kount++] = *vit;
1677  }
1678 
1680  delete[] basisIdx[ 1];
1681  basicVars.clear();
1682  }
1683 
1684  if(nonBasicUpper.size() > 0)
1685  {
1686 
1687  kount = 0;
1688 
1689  basisIdx[ 2] = new int[ nonBasicUpper.size()];
1690 
1691  for(vit = nonBasicUpper.begin(); vit < nonBasicUpper.end(); vit++)
1692  {
1693  basisIdx[2][ kount++] = *vit;
1694  }
1695 
1697  delete[] basisIdx[ 2];
1698  nonBasicUpper.clear();
1699  }
1700 
1701  if(nonBasicLower.size() > 0)
1702  {
1703  kount = 0;
1704 
1705  basisIdx[ 3] = new int[ nonBasicLower.size()];
1706 
1707  for(vit = nonBasicLower.begin(); vit < nonBasicLower.end(); vit++)
1708  {
1709  basisIdx[3][ kount++] = *vit;
1710  }
1711 
1713  delete[] basisIdx[ 3];
1714  nonBasicLower.clear();
1715 
1716  }
1717  //end get basis information for variables
1718 
1719 
1720  }// end of if on integer variables
1721 
1722 
1723  // now put the reduced costs into the osrl
1724  // Symphony does not get reduced costs
1725  if( sSolverName.find( "symphony") == std::string::npos && osinstance->getNumberOfIntegerVariables() == 0 && osinstance->getNumberOfBinaryVariables() == 0)
1726  {
1727  // first set the number of Other Variable Results
1728  if(numOfIntVars <= 0)
1729  {
1730  osresult->setNumberOfOtherVariableResults(solIdx, numberOfOtherVariableResults);
1731  for(i=0; i < numberOfVar; i++)
1732  {
1733  rcost[ i] = os_dtoa_format( solver->getReducedCost()[ i]);
1734  }
1735  osresult->setAnOtherVariableResultSparse(solIdx, otherIdx, "reduced_costs", "", "the variable reduced costs", idx, rcost, solver->getNumCols(), "", "double", "");
1736  // end of setting reduced costs
1737  }
1738  }
1739 
1740  ostringstream temp;
1741  temp << solver->getIterationCount();
1742  if (!osresult->setAnOtherSolutionResult(0,"iterations",temp.str(),"","",0,NULL))
1743  throw ErrorClass("error setting iteration count");
1744 
1746 
1747  if (y != NULL)
1748  {
1749  delete[] y;
1750  y = NULL;
1751  }
1752 
1753  if (rbasis != NULL)
1754  {
1755  delete[] rbasis;
1756  rbasis = NULL;
1757  }
1758 
1759  delete[] z;
1760  z = NULL;
1761 
1762  delete[] basisIdx;
1763  basisIdx = NULL;
1764 
1765  if (x != NULL)
1766  {
1767  delete[] x;
1768  x = NULL;
1769  }
1770 
1771  if (cbasis != NULL)
1772  {
1773  delete[] cbasis;
1774  cbasis = NULL;
1775  }
1776 
1777  if (rcost != NULL)
1778  {
1779  delete[] rcost;
1780  rcost = NULL;
1781  }
1782 
1783  if (idx != NULL)
1784  {
1785  delete[] idx;
1786  idx = NULL;
1787  }
1788  }
1789 
1790  catch(const ErrorClass& eclass)
1791  {
1792  if (y != NULL)
1793  {
1794  delete[] y;
1795  y = NULL;
1796  }
1797 
1798  if (rbasis != NULL)
1799  {
1800  delete[] rbasis;
1801  rbasis = NULL;
1802  }
1803 
1804  delete[] z;
1805  z = NULL;
1806 
1807  delete[] basisIdx;
1808  basisIdx = NULL;
1809 
1810  if (x != NULL)
1811  {
1812  delete[] x;
1813  x = NULL;
1814  }
1815 
1816  if (cbasis != NULL)
1817  {
1818  delete[] cbasis;
1819  cbasis = NULL;
1820  }
1821 
1822  if (rcost != NULL)
1823  {
1824  delete[] rcost;
1825  rcost = NULL;
1826  }
1827 
1828  if (idx != NULL)
1829  {
1830  delete[] idx;
1831  idx = NULL;
1832  }
1833 
1835  osresult->setGeneralStatusType( "error");
1837  throw ErrorClass( osrl) ;
1838  }
1839 }//writeResult(OsiSolverInterface)
1840 
1841 
1842 void CoinSolver::writeResult(CbcModel *model)
1843 {
1844  double *x = NULL;
1845  double *y = NULL;
1846 
1847  double *z = NULL;
1848  int *idx = NULL;
1849  std::string *rcost = NULL;
1850  //if( osinstance->getVariableNumber() > 0 ) x = new double[osinstance->getVariableNumber() ];
1851  if( model->getNumCols() > 0 ) x = new double[model->getNumCols() ];
1852  if( model->getNumRows() > 0 ) y = new double[model->getNumRows() ];
1853  if( model->getNumCols() > 0 ) idx = new int[ model->getNumCols() ];
1854  z = new double[1];
1855  if( model->getNumCols() > 0 ) rcost = new std::string[ model->getNumCols()];
1856 
1857  int numberOfOtherVariableResults = 1;
1858  int otherIdx = 0;
1859  int numberOfVar = model->getNumCols();
1861  int i = 0;
1862  int solIdx = 0;
1863  std::string description = "";
1864  osresult->setGeneralStatusType("normal");
1866 
1868 
1869  //first determine if we are feasible
1870  int numberIntegerInfeasibilities = 0;
1871  int numberObjectInfeasibilities = 0;
1872  bool isFeasible = false;
1873  isFeasible = model->feasibleSolution( numberIntegerInfeasibilities,
1874  numberObjectInfeasibilities);
1875  std::string statusMsg;
1876  if(isFeasible == true)
1877  {
1878  statusMsg = "feasible";
1879  }
1880  else
1881  {
1882  statusMsg = "infeasible";
1883  }
1884 
1885 
1886  if (model->isProvenOptimal() == true )
1887  {
1888  osresult->setSolutionStatus(solIdx, "optimal", description);
1889  }
1890  else
1891  {
1892  if(model->isProvenInfeasible() == true)
1893  osresult->setSolutionStatus(solIdx, "infeasible", "the integer program is infeasible");
1894  else
1895  {
1896  if(model->isProvenDualInfeasible() == true)
1897  osresult->setSolutionStatus(solIdx, "infeasible", "the continuous relaxation is dual infeasible");
1898  else
1899  {
1900  if(model->isContinuousUnbounded() == true)
1901  osresult->setSolutionStatus(solIdx, statusMsg, "the continuous relaxation is unbounded");
1902  else
1903  {
1904  if(model->isNodeLimitReached() == true)
1905  osresult->setSolutionStatus(solIdx, statusMsg, "node limit reached");
1906  else
1907  {
1908  if(model->isSecondsLimitReached() == true)
1909  osresult->setSolutionStatus(solIdx, statusMsg, "time limit reached");
1910  else
1911  {
1912  if(model->isSolutionLimitReached() == true)
1913  osresult->setSolutionStatus(solIdx, statusMsg, "solution limit reached");
1914  else
1915  {
1916  if(model->isAbandoned() == true)
1917  osresult->setSolutionStatus(solIdx, statusMsg, "there are numerical difficulties");
1918  else
1919  osresult->setSolutionStatus(solIdx, statusMsg,"unknown");
1920  }
1921  }
1922  }
1923  }
1924  }
1925  }
1926  }
1927 
1928  /* Retrieve the solution -- of course it may not be optimal */
1929  if(numOfIntVars > 0) *(z + 0) = model->getObjValue();
1930  osresult->setObjectiveValuesDense(solIdx, z);
1931  for(i=0; i < model->getNumCols(); i++)
1932  {
1933  *(x + i) = model->getColSolution()[i];
1934  *(idx + i) = i;
1935  }
1937  for(i=0; i < model->getNumRows(); i++)
1938  {
1939  *(y + i) = model->getRowPrice()[ i];
1940  }
1941  if(numOfIntVars <= 0) osresult->setDualVariableValuesDense(solIdx, y);
1942  // now put the reduced costs into the osrl
1943  // first set the number of Other Variable Results
1944  if(numOfIntVars <= 0)
1945  {
1946  osresult->setNumberOfOtherVariableResults(solIdx, numberOfOtherVariableResults);
1947  for(i=0; i < numberOfVar; i++)
1948  {
1949  rcost[ i] = os_dtoa_format( model->getReducedCost()[ i]);
1950  }
1951  osresult->setAnOtherVariableResultSparse(solIdx, otherIdx, "reduced_costs", "", "the variable reduced costs", idx, rcost, model->getNumCols());
1952  }
1953  // end of setting reduced costs
1955  //garbage collection
1956  if(model->getNumCols() > 0) delete[] x;
1957  x = NULL;
1958  if(model->getNumRows() > 0) delete[] y;
1959  y = NULL;
1960  delete[] z;
1961  z = NULL;
1962  if(model->getNumCols() > 0)
1963  {
1964  delete[] rcost;
1965  rcost = NULL;
1966  delete[] idx;
1967  idx = NULL;
1968  }
1969 }//writeResult( CbcModel)
1970 
1971 
const OSSmartPtr< OSOutput > osoutput
Definition: OSOutput.cpp:39
std::string os_dtoa_format(double x)
Definition: OSMathUtil.cpp:154
std::string OSgetVersionInfo()
for(;;)
double os_strtod(const char *s00, char **se)
Definition: OSdtoa.cpp:2541
const char ** cbc_argv
when Cbc is the solver, these are the arguments sent to Cbc Solve
Definition: OSCoinSolver.h:134
virtual void setSolverOptions()
The implementation of the corresponding virtual function.
virtual void buildSolverInstance()
The implementation of the corresponding virtual function.
int num_cbc_argv
the number of arguments in the argument list to the Cbc Solver
Definition: OSCoinSolver.h:138
CoinPackedMatrix * m_CoinPackedMatrix
m_CoinPackedMatrix is a Coin Packed Matrix ojbect
Definition: OSCoinSolver.h:126
std::string getCoinSolverType(std::string osol_)
Get the solver type, e.g. clp or glpk.
OSiLReader * m_osilreader
m_osilreader is an OSiLReader object used to create an osinstance from an osil string if needed
Definition: OSCoinSolver.h:101
OsiSolverInterface * osiSolver
osiSolver is the osi solver object – in this case clp, glpk, cbc, cplex, symphony or dylp
Definition: OSCoinSolver.h:93
CoinSolver()
The class constructor.
~CoinSolver()
The class destructor.
OSoLReader * m_osolreader
m_osolreader is an OSoLReader object used to create an osoption from an osol string if needed
Definition: OSCoinSolver.h:107
void writeResult(OsiSolverInterface *solver)
OSrLWriter * osrlwriter
osrlwriter object used to write osrl from an OSResult object
Definition: OSCoinSolver.h:129
virtual void solve()
The implementation of the corresponding virtual function.
void dataEchoCheck()
Print out problem parameters.
bool setCoinPackedMatrix()
Create a CoinPackedMatrix.
double cpuTime
Definition: OSCoinSolver.h:140
BasisStatus * initialBasisStatus
initial basis status for the slack variables
Definition: OSOption.h:3277
std::string sSolverName
sSolverName is the name of the Coin solver used, e.g.
std::string osol
osol holds the options for the solver
bool bSetSolverOptions
bSetSolverOptions is set to true if setSolverOptions has been called, false otherwise
std::string osrl
osrl holds the solution or result of the model
OSInstance * osinstance
osinstance holds the problem instance in-memory as an OSInstance object
bool bCallbuildSolverInstance
bCallbuildSolverInstance is set to true if buildSolverService has been called
std::string osil
osil holds the problem instance as a std::string
OSOption * osoption
osoption holds the solver options in-memory as an OSOption object
OSResult * osresult
osresult holds the solution or result of the model in-memory as an OSResult object
used for throwing exceptions.
Definition: OSErrorClass.h:32
std::string errormsg
errormsg is the error that is causing the exception to be thrown
Definition: OSErrorClass.h:42
the InitVarValue class.
Definition: OSOption.h:1160
double value
initial value
Definition: OSOption.h:1170
int idx
variable index
Definition: OSOption.h:1164
Variables * variables
variables is a pointer to a Variables object
Definition: OSInstance.h:2185
Objectives * objectives
objectives is a pointer to a Objectives object
Definition: OSInstance.h:2188
double * getConstraintLowerBounds()
Get constraint lower bounds.
int getNumberOfQuadraticTerms()
Get the number of specified (usually nonzero) qTerms in the quadratic coefficients.
double * getVariableUpperBounds()
Get variable upper bounds.
int getNumberOfIntegerVariables()
getNumberOfIntegerVariables
int getNumberOfBinaryVariables()
getNumberOfBinaryVariables
bool getLinearConstraintCoefficientMajor()
Get whether the constraint coefficients is in column major (true) or row major (false).
std::string getInstanceDescription()
Get instance description.
std::string getInstanceSource()
Get instance source.
int getConstraintNumber()
Get number of constraints.
int getNumberOfStringVariables()
getNumberOfStringVariables
int getLinearConstraintCoefficientNumber()
Get number of specified (usually nonzero) linear constraint coefficient values.
int getNumberOfSemiIntegerVariables()
getNumberOfSemiIntegerVariables
SparseMatrix * getLinearConstraintCoefficientsInRowMajor()
Get linear constraint coefficients in row major.
char * getVariableTypes()
Get variable initial values.
SparseMatrix * getLinearConstraintCoefficientsInColumnMajor()
Get linear constraint coefficients in column major.
int getNumberOfSemiContinuousVariables()
getNumberOfSemiContinuousVariables
double ** getDenseObjectiveCoefficients()
getDenseObjectiveCoefficients.
InstanceData * instanceData
A pointer to an InstanceData object.
Definition: OSInstance.h:2278
int getNumberOfNonlinearExpressions()
Get number of nonlinear expressions.
QuadraticTerms * getQuadraticTerms()
Get all the quadratic terms in the instance.
double * getObjectiveConstants()
Get objective constants.
double * getVariableLowerBounds()
Get variable lower bounds.
int getVariableNumber()
Get number of variables.
std::string * getVariableNames()
Get variable names.
std::string getInstanceName()
Get instance name.
std::string * getConstraintNames()
Get constraint names.
std::string * getObjectiveMaxOrMins()
Get objective maxOrMins.
double * getConstraintUpperBounds()
Get constraint upper bounds.
int getObjectiveNumber()
Get number of objectives.
OptimizationOption * optimization
optimizationOption holds the fifth child of the OSOption specified by the OSoL Schema.
Definition: OSOption.h:3596
InitVarValue ** getInitVarValuesSparse()
Get the initial values associated with the variables in sparse form.
Definition: OSOption.cpp:2719
int getNumberOfInitVarValues()
Get the number of initial variable values.
Definition: OSOption.cpp:2051
int getNumberOfInitialBasisElements(int type, int status)
Get the number of initial basis elements for a particular variable type and basis status.
Definition: OSOption.cpp:3073
std::vector< SolverOption * > getSolverOptions(std::string solver_name)
Get the options associated with a given solver.
Definition: OSOption.cpp:4508
int getNumberOfSolverOptions()
Get the number of solver options.
Definition: OSOption.cpp:2207
bool getInitialBasisElements(int type, int status, int *elem)
Get the initial basis elements for a particular variable type and basis status.
Definition: OSOption.cpp:3115
The Result Class.
Definition: OSResult.h:2549
bool setGeneralMessage(std::string message)
Set the general message.
bool setSolutionNumber(int number)
set the number of solutions.
Definition: OSResult.cpp:4740
bool setInstanceName(std::string instanceName)
Set instance name.
bool setObjectiveValuesDense(int solIdx, double *objectiveValues)
Set the [i]th optimization solution's objective values, where i equals the given solution index.
Definition: OSResult.cpp:5824
bool setNumberOfOtherVariableResults(int solIdx, int numberOfOtherVariableResults)
Set the [i]th optimization solution's other (non-standard/solver specific) variable-related results,...
Definition: OSResult.cpp:5236
bool setGeneralStatusType(std::string type)
Set the general status type, which can be: success, error, warning.
bool setObjectiveNumber(int objectiveNumber)
Set the objective number.
Definition: OSResult.cpp:4721
bool setPrimalVariableValuesDense(int solIdx, double *x)
Set the [i]th optimization solution's primal variable values, where i equals the given solution index...
Definition: OSResult.cpp:5001
bool setServiceName(std::string serviceName)
Set service name.
bool setSolverInvoked(std::string solverInvoked)
Set solver invoked.
Definition: OSResult.cpp:4155
bool setVariableNumber(int variableNumber)
Set the variable number.
Definition: OSResult.cpp:4712
bool setTime(double time)
Set time.
Definition: OSResult.cpp:4482
bool setDualVariableValuesDense(int solIdx, double *y)
Set the [i]th optimization solution's dual variable values, where i equals the given solution index.
Definition: OSResult.cpp:6291
bool setSolutionMessage(int solIdx, std::string msg)
Set the [i]th optimization solution's message, where i equals the given solution index.
Definition: OSResult.cpp:4917
bool setSolutionStatus(int solIdx, std::string type, std::string description)
Set the [i]th optimization solution status, where i equals the given solution index.
bool setAnOtherVariableResultSparse(int solIdx, int otherIdx, std::string name, std::string value, std::string description, int *idx, std::string *s, int n)
Set the [i]th optimization solution's other (non-standard/solver specific)variable-related results,...
bool setConstraintNumber(int constraintNumber)
Set the constraint number.
Definition: OSResult.cpp:4731
bool setBasisStatus(int solIdx, int object, int status, int *i, int ni)
Set the basis status of a number of variables/constraints/objectives.
Definition: OSResult.cpp:5192
bool setAnOtherSolutionResult(int solIdx, std::string name, std::string value, std::string category, std::string description, int numberOfItems, std::string *item)
Set another solution result of solution [i].
Definition: OSResult.cpp:7344
Used to read an OSiL string.
Definition: OSiLReader.h:38
OSInstance * readOSiL(const std::string &osil)
parse the OSiL model instance.
Definition: OSiLReader.cpp:53
Used to read an OSoL string.
Definition: OSoLReader.h:38
OSOption * readOSoL(const std::string &osol)
parse the OSoL solver options.
Definition: OSoLReader.cpp:76
Take an OSResult object and write a string that validates against OSrL.
Definition: OSrLWriter.h:31
std::string writeOSrL(OSResult *theosresult)
create an osrl string from an OSResult object
Definition: OSrLWriter.cpp:45
int numberOfObjectives
numberOfObjectives is the number of objective functions in the instance
Definition: OSInstance.h:201
Objective ** obj
coef is pointer to an array of ObjCoef object pointers
Definition: OSInstance.h:205
VariableOption * variables
the options for the variables
Definition: OSOption.h:3509
ConstraintOption * constraints
the options for the constraints
Definition: OSOption.h:3515
a data structure for holding quadratic terms
Definition: OSGeneral.h:432
int * varTwoIndexes
varTwoIndexes holds an integer array of the second variable indexes of all the quadratic terms.
Definition: OSGeneral.h:450
int * rowIndexes
rowIndexes holds an integer array of row indexes of all the quadratic terms.
Definition: OSGeneral.h:440
double * coefficients
coefficients holds a double array all the quadratic term coefficients.
Definition: OSGeneral.h:455
int * varOneIndexes
varOneIndexes holds an integer array of the first variable indexes of all the quadratic terms.
Definition: OSGeneral.h:445
int * indexes
indexes holds an integer array of rowIdx (or colIdx) elements in coefMatrix (AMatrix).
Definition: OSGeneral.h:258
int * starts
starts holds an integer array of start elements in coefMatrix (AMatrix), which points to the start of...
Definition: OSGeneral.h:252
double * values
values holds a double array of value elements in coefMatrix (AMatrix), which contains nonzero element...
Definition: OSGeneral.h:264
double ub
ub corresponds to the optional attribute that holds the variable upper bound.
Definition: OSInstance.h:61
double lb
lb corresponds to the optional attribute that holds the variable lower bound.
Definition: OSInstance.h:56
BasisStatus * initialBasisStatus
initial basis information
Definition: OSOption.h:2110
Variable ** var
Here we define a pointer to an array of var pointers.
Definition: OSInstance.h:97
const double OSDBL_MAX
Definition: OSParameters.h:93
@ ENUM_OUTPUT_LEVEL_detailed_trace
Definition: OSParameters.h:116
@ ENUM_OUTPUT_LEVEL_debug
Definition: OSParameters.h:114
@ ENUM_OUTPUT_LEVEL_trace
Definition: OSParameters.h:115
@ ENUM_OUTPUT_LEVEL_error
Definition: OSParameters.h:110
@ ENUM_OUTPUT_LEVEL_info
Definition: OSParameters.h:113
@ ENUM_BASIS_STATUS_isFree
Definition: OSParameters.h:462
@ ENUM_BASIS_STATUS_basic
Definition: OSParameters.h:458
@ ENUM_BASIS_STATUS_atLower
Definition: OSParameters.h:459
@ ENUM_BASIS_STATUS_atUpper
Definition: OSParameters.h:460
@ ENUM_OUTPUT_AREA_OSSolverInterfaces
Definition: OSParameters.h:145
@ ENUM_PROBLEM_COMPONENT_constraints
Definition: OSParameters.h:556
@ ENUM_PROBLEM_COMPONENT_variables
Definition: OSParameters.h:554