Changeset 348


Ignore:
Timestamp:
Nov 12, 2009 11:33:43 AM (10 years ago)
Author:
bjarni
Message:

Move PCBC handling to separate source file CoinCbc?.c and CoinCbc?.h

Location:
trunk/CoinMP
Files:
2 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CoinMP/MSVisualStudio/v9/CoinMP/CoinMP.vcproj

    r344 r348  
    201201                        </File>
    202202                        <File
     203                                RelativePath="..\..\..\src\CoinCbc.cpp"
     204                                >
     205                        </File>
     206                        <File
    203207                                RelativePath="..\..\..\src\CoinMP.cpp"
    204208                                >
     
    235239                        </File>
    236240                        <File
     241                                RelativePath="..\..\..\src\CoinCbc.h"
     242                                >
     243                        </File>
     244                        <File
    237245                                RelativePath="..\..\..\src\CoinMP.h"
    238246                                >
  • trunk/CoinMP/src/CoinMP.cpp

    r344 r348  
    2525#include "CoinSolver.h"
    2626
    27 
    28 #include <cfloat>
    29 
    30 #include "CoinHelperFunctions.hpp"
    31 #include "CoinMessageHandler.hpp"
    32 
    33 #include "ClpSimplex.hpp"
    34 #include "ClpPrimalColumnSteepest.hpp"
    35 #include "ClpDualRowSteepest.hpp"
    36 #include "ClpEventHandler.hpp"
    37 
    38 #include "OsiSolverInterface.hpp"
    39 #include "OsiClpSolverInterface.hpp"
    40 
    41 #include "CbcModel.hpp"
    42 #include "CbcSolver.hpp"
    43 #include "CbcEventHandler.hpp"
    44 #include "CbcBranchActual.hpp"
    45 
    46 #include "CglProbing.hpp"
    47 #include "CglGomory.hpp"
    48 #include "CglKnapsackCover.hpp"
    49 #include "CglOddHole.hpp"
    50 #include "CglClique.hpp"
    51 #include "CglLiftAndProject.hpp"
    52 #include "CglSimpleRounding.hpp"
    53 
     27#include "CoinCbc.h"
    5428
    5529
     
    145119
    146120/************************************************************************/
    147 /*  Message Callback Handler                                            */
    148 /************************************************************************/
    149 
    150 
    151 class CBMessageHandler : public CoinMessageHandler {
    152 public:
    153         void setCallback(MSGLOGCALLBACK msgCallback);
    154         virtual int print();
    155 private:
    156         MSGLOGCALLBACK msgCallback_;
    157 };
    158 
    159 
    160 void CBMessageHandler::setCallback(MSGLOGCALLBACK msgCallback)
    161 {
    162   msgCallback_ = msgCallback;
    163 }
    164 
    165 
    166 int CBMessageHandler::print()
    167 {
    168         msgCallback_(const_cast<char*>(messageBuffer()));
    169         return CoinMessageHandler::print();
    170 }
    171 
    172 
    173 
    174 /************************************************************************/
    175 /*  Iteration Callback Handler                                          */
    176 /************************************************************************/
    177 
    178 
    179 class CBIterHandler : public ClpEventHandler {
    180 
    181 public:
    182    void setIterCallback(ITERCALLBACK iterCallback);
    183 
    184         virtual int event(Event whichEvent);
    185    
    186   /** Default constructor. */
    187   CBIterHandler();
    188   /// Constructor with pointer to model (redundant as setEventHandler does)
    189   CBIterHandler(ClpSimplex * model);
    190   /** Destructor */
    191   virtual ~CBIterHandler();
    192   /** The copy constructor. */
    193   CBIterHandler(const CBIterHandler & rhs);
    194   /// Assignment
    195   CBIterHandler& operator=(const CBIterHandler & rhs);
    196   /// Clone
    197   virtual ClpEventHandler * clone() const ;
    198 
    199 
    200 private:
    201         ITERCALLBACK iterCallback_;
    202 };
    203 
    204 
    205 void CBIterHandler::setIterCallback(ITERCALLBACK iterCallback)
    206 {
    207   iterCallback_ = iterCallback;
    208 }
    209 
    210 
    211 
    212 int CBIterHandler::event(Event whichEvent)
    213 {
    214         int numIter;
    215         double objValue;
    216         int isPrimalFeasible;
    217         int isDualFeasible;
    218         double sumPrimalInfeas;
    219         double sumDualInfeas;
    220         int cancelAsap;
    221 
    222         if ((whichEvent==endOfIteration)) {
    223                 numIter = model_->getIterationCount();
    224                 objValue = model_->getObjValue();
    225                 sumDualInfeas = model_->sumDualInfeasibilities();
    226                 sumPrimalInfeas = model_->sumPrimalInfeasibilities();
    227                 isPrimalFeasible = model_->primalFeasible();
    228                 isDualFeasible = model_->dualFeasible();
    229                 cancelAsap = iterCallback_(numIter, objValue, isPrimalFeasible&&isDualFeasible, sumPrimalInfeas);
    230                 if (cancelAsap) {
    231                         return 5;
    232                 }
    233         }
    234         return -1;
    235 }
    236 
    237 
    238 // Default Constructor
    239 CBIterHandler::CBIterHandler () : ClpEventHandler() {}
    240 
    241 // Copy constructor
    242 CBIterHandler::CBIterHandler (const CBIterHandler & rhs) : ClpEventHandler(rhs) {}
    243 
    244 // Constructor with pointer to model
    245 CBIterHandler::CBIterHandler(ClpSimplex * model) : ClpEventHandler(model) {}
    246 
    247 // Destructor
    248 CBIterHandler::~CBIterHandler () {}
    249 
    250 // Assignment operator
    251 CBIterHandler & CBIterHandler::operator=(const CBIterHandler& rhs)
    252 {
    253   if (this != &rhs) {
    254     ClpEventHandler::operator=(rhs);
    255   }
    256   return *this;
    257 }
    258 
    259 // Clone
    260 ClpEventHandler * CBIterHandler::clone() const
    261 {
    262         CBIterHandler * iterhandler;
    263 
    264    iterhandler = new CBIterHandler(*this);
    265         iterhandler->iterCallback_ = this->iterCallback_;
    266         return iterhandler;
    267 }
    268 
    269 
    270 
    271 /************************************************************************/
    272 /*  Mip Node Callback Handler                                           */
    273 /************************************************************************/
    274 
    275 
    276 class CBNodeHandler : public CbcEventHandler {
    277 
    278 public:
    279    void setCallback(MIPNODECALLBACK mipNodeCallback);
    280 
    281         virtual CbcAction event(CbcEvent whichEvent);
    282    
    283   /** Default constructor. */
    284   CBNodeHandler();
    285   /// Constructor with pointer to model (redundant as setEventHandler does)
    286   //JPF CBNodeHandler(ClpSimplex * model);
    287   CBNodeHandler(CbcModel * model);
    288  
    289 
    290   /** Destructor */
    291   virtual ~CBNodeHandler();
    292   /** The copy constructor. */
    293   CBNodeHandler(const CBNodeHandler & rhs);
    294   /// Assignment
    295   CBNodeHandler& operator=(const CBNodeHandler & rhs);
    296   /// Clone
    297   virtual CbcEventHandler * clone() const ;
    298 
    299 
    300 private:
    301         MIPNODECALLBACK mipNodeCallback_;
    302         int lastSolCount_;
    303 };
    304 
    305 
    306 void CBNodeHandler::setCallback(MIPNODECALLBACK mipNodeCallback)
    307 {
    308   mipNodeCallback_ = mipNodeCallback;
    309   lastSolCount_ = 0;
    310 }
    311 
    312 
    313 CBNodeHandler::CbcAction CBNodeHandler::event(CbcEvent whichEvent)
    314 {
    315         int numIter;
    316         int numNodes;
    317         double bestBound;
    318         double objValue;
    319         int solCount;
    320         int cancelAsap;
    321 
    322         if (whichEvent==node) {
    323                 numIter = model_->getIterationCount();
    324                 numNodes = model_->getNodeCount();
    325                 objValue = model_->getObjValue();
    326                 bestBound = model_->getBestPossibleObjValue();
    327                 solCount = model_->getSolutionCount();
    328                 cancelAsap = mipNodeCallback_(numIter, numNodes, bestBound, objValue, solCount != lastSolCount_);
    329                 lastSolCount_ = solCount;
    330                 if (cancelAsap) {
    331                         return stop;
    332                 }
    333         }
    334         return noAction;
    335 }
    336 
    337 
    338 // Default Constructor
    339 CBNodeHandler::CBNodeHandler () : CbcEventHandler() {}
    340 
    341 // Copy constructor
    342 CBNodeHandler::CBNodeHandler (const CBNodeHandler & rhs) : CbcEventHandler(rhs) {}
    343 
    344 // Constructor with pointer to model
    345 //JPF: CBNodeHandler::CBNodeHandler(ClpSimplex * model) : CbcEventHandler(model) {}
    346 CBNodeHandler::CBNodeHandler(CbcModel * model) : CbcEventHandler(model) {}
    347 
    348 // Destructor
    349 CBNodeHandler::~CBNodeHandler () {}
    350 
    351 // Assignment operator
    352 CBNodeHandler & CBNodeHandler::operator=(const CBNodeHandler& rhs)
    353 {
    354   if (this != &rhs) {
    355     CbcEventHandler::operator=(rhs);
    356   }
    357   return *this;
    358 }
    359 
    360 // Clone
    361 CbcEventHandler * CBNodeHandler::clone() const
    362 {
    363         CBNodeHandler * nodehandler;
    364 
    365         nodehandler = new CBNodeHandler(*this);
    366         nodehandler->mipNodeCallback_ = this->mipNodeCallback_;
    367         nodehandler->lastSolCount_ = this->lastSolCount_;
    368         return nodehandler;
    369 }
    370 
    371 
    372 
    373 /************************************************************************/
    374121/*  Coin Problem Info Structure                                         */
    375122/************************************************************************/
     
    377124
    378125typedef struct {
    379                                 ClpSimplex *clp;
    380                                 ClpSolve *clp_presolve;
    381                                 OsiClpSolverInterface *osi;
    382                                 CbcModel *cbc;
    383                                 int CbcMain0Already;
    384 
    385                                 CBMessageHandler *msghandler;
    386                                 CBIterHandler *iterhandler;
    387                                 CBNodeHandler *nodehandler;
    388 
    389                                 CglProbing *probing;
    390                                 CglGomory *gomory;
    391                                 CglKnapsackCover *knapsack;
    392                                 CglOddHole *oddhole;
    393                                 CglClique *clique;
    394                                 CglLiftAndProject *liftpro;
    395                                 CglSimpleRounding *rounding;
    396 
    397126                                PPROBLEM  pProblem;
    398127                                PRESULT   pResult;
     
    403132
    404133
    405 PCOIN global_pCoin;
     134//PCOIN global_pCoin;
    406135
    407136
     
    417146
    418147        pCoin = (PCOIN) malloc(sizeof(COININFO));
    419         global_pCoin = pCoin;
    420         pCoin->clp = new ClpSimplex();
    421         pCoin->clp_presolve = new ClpSolve();
    422         pCoin->osi = new OsiClpSolverInterface(pCoin->clp);
    423         pCoin->cbc = NULL;  /* ERRORFIX 2/22/05: Crashes if not NULL when trying to set message handler */
    424         pCoin->CbcMain0Already = 0;
    425 
    426         pCoin->msghandler = NULL;
    427         pCoin->iterhandler = NULL;
    428         pCoin->nodehandler = NULL;
    429148
    430149        pCoin->pProblem = coinCreateProblemObject();
     
    433152
    434153        coinSetProblemName(pCoin->pProblem, ProblemName);
     154        coinCopyOptionTable(pCoin->pSolver, CbcGetOptionTable(), CbcGetOptionCount());
    435155
    436156        return (HPROB)pCoin;
     
    438158
    439159
    440 
    441 void coinCopyNamesList(PPROBLEM pProblem, PCOIN pCoin)
    442 {
    443         int i;
    444 
    445         /* Load names */
    446         if (pProblem->RowNamesList || pProblem->ColNamesList) {
    447                 std::vector<std::string> rowNamesVect;
    448                 std::vector<std::string> colNamesVect;
    449                 rowNamesVect.reserve(pProblem->RowCount);
    450                 colNamesVect.reserve(pProblem->ColCount);
    451                 if (pProblem->RowNamesList) {
    452                         for (i = 0; i < pProblem->RowCount; i++) {
    453                                 rowNamesVect.push_back(pProblem->RowNamesList[i]);
    454                         }
    455                 }
    456                 if (pProblem->ColNamesList) {
    457                         for (i = 0; i < pProblem->ColCount; i++) {
    458                                 colNamesVect.push_back(pProblem->ColNamesList[i]);
    459                         }
    460                 }
    461                 pCoin->clp->copyNames(rowNamesVect, colNamesVect);
    462         }
     160SOLVAPI int SOLVCALL CoinUnloadProblem(HPROB hProb)
     161{
     162   PCOIN pCoin = (PCOIN)hProb;
     163       
     164        if (pCoin) {
     165                coinClearProblemObject(pCoin->pProblem);
     166                coinClearResultObject(pCoin->pResult);
     167                coinClearSolverObject(pCoin->pSolver);
     168        }
     169        free(pCoin);
     170        pCoin = NULL;
     171        return SOLV_CALL_SUCCESS;
    463172}
    464173
     
    529238        coinCopyNamesList(pProblem->RowNamesList, pProblem->RowNamesBuf, RowNames, RowCount);
    530239
    531         pCoin->clp->setOptimizationDirection(ObjectSense);
    532 
    533240        if (!coinComputeRowLowerUpper(pProblem, COIN_DBL_MAX)) {
    534241                return SOLV_CALL_FAILED;
    535242        }
    536 
    537         pCoin->clp->loadProblem(ColCount, RowCount, MatrixBegin, MatrixIndex, MatrixValues,
    538                                                         LowerBounds, UpperBounds, ObjectCoeffs, pProblem->RowLower, pProblem->RowUpper);
    539 
    540         coinCopyNamesList(pProblem, pCoin);
    541 
    542         return SOLV_CALL_SUCCESS;
    543 }
    544 
    545 // CoinLoadProblemBuf accepts ColNames/RowNames as character buffer with \0 after each name
     243        return SOLV_CALL_SUCCESS;
     244}
     245
     246// CoinLoadProblemBuf accepts ColNamesBuf/RowNamesBuf as character buffer with \0 after each name
    546247
    547248SOLVAPI int SOLVCALL CoinLoadProblemBuf(HPROB hProb,
     
    577278        PPROBLEM pProblem = pCoin->pProblem;
    578279
     280        if (!InitValues) {
     281                return SOLV_CALL_FAILED;
     282        }       
    579283        if (InitValues)   pProblem->InitValues   = (double* ) malloc(pProblem->ColCount     * sizeof(double));
    580284
     
    593297                return SOLV_CALL_FAILED;
    594298        }
    595         if (ColType) {
    596                 pProblem->ColType = (char* )malloc(pProblem->ColCount * sizeof(char));
    597                 if (!pProblem->ColType) {
    598                         return SOLV_CALL_FAILED;
    599                 }
    600                 memcpy(pProblem->ColType, ColType, pProblem->ColCount * sizeof(char));
    601         }
    602         pProblem->IsInt = (char* )malloc(pProblem->ColCount*sizeof(char));
     299        if (!ColType) {
     300                return SOLV_CALL_FAILED;
     301        }
     302        pProblem->ColType = (char* )malloc(pProblem->ColCount * sizeof(char));
     303        if (!pProblem->ColType) {
     304                return SOLV_CALL_FAILED;
     305        }
     306        memcpy(pProblem->ColType, ColType, pProblem->ColCount * sizeof(char));
     307
     308        pProblem->IsInt = (char* )malloc(pProblem->ColCount * sizeof(char));
    603309        if (!pProblem->IsInt) {
    604310                return SOLV_CALL_FAILED;
     
    609315                                pProblem->BinCount++;
    610316                                pProblem->IsInt[i] = 1;
    611                                 pProblem->SolveAsMIP = 1;
    612317                                break;
    613318
     
    615320                                pProblem->IntCount++;
    616321                                pProblem->IsInt[i] = 1;
    617                                 pProblem->SolveAsMIP = 1;
    618322                                break;
    619323
    620                         case 'C':
     324                        default:
    621325                                pProblem->IsInt[i] = 0;
    622326                                break;
    623 
    624                         default:
    625                                 pProblem->IsInt[i] = 0;
    626                                 return SOLV_CALL_FAILED;
    627                 }
    628         }
    629         if (pProblem->SolveAsMIP) {
    630                 if (!pCoin->cbc) {
    631                         pCoin->cbc = new CbcModel(*pCoin->osi);
    632                 }
    633                 for (i = 0; i < pProblem->ColCount; i++) {
    634                         if (pProblem->IsInt[i]) {
    635                                 pCoin->cbc->solver()->setInteger(i);
    636                                 pCoin->osi->setInteger(i);
    637                                 pProblem->numInts++;
    638                         }
    639                 }
    640 #ifdef NEW_STYLE_CBCMAIN
    641                 if (CoinGetIntOption(hProb, COIN_INT_MIPUSECBCMAIN)) {
    642                         if (!pCoin->CbcMain0Already) {
    643                                 CbcMain0(*pCoin->cbc);
    644                                 pCoin->CbcMain0Already = 1;
    645                         }
    646                 }
    647 #endif
     327                }
     328        }
     329        pProblem->numInts = pProblem->IntCount + pProblem->BinCount;
     330        if (pProblem->numInts > 0) {
     331                pProblem->SolveAsMIP = 1;
    648332        }
    649333        return SOLV_CALL_SUCCESS;
     
    657341        PCOIN pCoin = (PCOIN)hProb;
    658342        PPROBLEM pProblem = pCoin->pProblem;
    659         int *priorVar;
    660         int *priorCbc;
    661         int i,k;
    662343
    663344        pProblem->PriorCount = PriorCount;
     
    669350        if (pProblem->BranchDir)   memcpy(pProblem->BranchDir,   BranchDir,   PriorCount * sizeof(int));
    670351
    671         if (!pProblem->SolveAsMIP) {
    672                 return SOLV_CALL_FAILED;
    673         }
    674         if (!pProblem->IsInt) {
    675                 return SOLV_CALL_FAILED;
    676         }
    677 
    678         priorVar = (int *)malloc(pProblem->ColCount * sizeof(int));
    679         if (!priorVar) {
    680                 return SOLV_CALL_FAILED;
    681         }
    682         //reset the priorVar
    683         for (i = 0; i < pProblem->ColCount; i++) {
    684                 priorVar[i] = 1000;
    685         }
    686         for (i = 0; i < PriorCount; i++) {
    687                 if ((PriorIndex[i] < 0) || (PriorIndex[i] >= pProblem->ColCount)) {
    688                         free(priorVar);
    689                         return SOLV_CALL_FAILED;
    690                 }
    691                 priorVar[PriorIndex[i]] = PriorValues[i];
    692         }
    693         //Create an array to give to cbc
    694         priorCbc = (int *)malloc(pProblem->numInts * sizeof(int));
    695         if (!priorCbc) {
    696                 free(priorVar);
    697                 return SOLV_CALL_FAILED;
    698         }
    699         k = 0;
    700         for (i = 0; i < pProblem->ColCount; i++) {
    701                 if (pProblem->IsInt[i]) {
    702                         priorCbc[k++] = priorVar[i];
    703                 }
    704         }
    705         pCoin->cbc->passInPriorities(priorCbc, false);
    706         free(priorCbc);
    707         free(priorVar);
    708352        return SOLV_CALL_SUCCESS;
    709353}
     
    722366        PCOIN pCoin = (PCOIN)hProb;
    723367        PPROBLEM pProblem = pCoin->pProblem;
    724         int sos, count;
    725         int* which;
    726         int type;
    727368
    728369        if ((SosCount == 0) || (SosNZCount == 0)) {
     
    745386
    746387        pProblem->SolveAsMIP = 1;
    747         if (!pCoin->cbc) {
    748                 pCoin->cbc = new CbcModel(*pCoin->osi);
    749         }
    750 #ifdef NEW_STYLE_CBCMAIN
    751         if (CoinGetIntOption(hProb, COIN_INT_MIPUSECBCMAIN)) {
    752                 if (!pCoin->CbcMain0Already) {
    753                         CbcMain0(*pCoin->cbc);
    754                         pCoin->CbcMain0Already = 1;
    755                 }
    756         }
    757 #endif
    758         for (sos = 0; sos < SosCount; sos++) {
    759                 count = SosBegin[sos+1] - SosBegin[sos];
    760                 which = &SosIndex[SosBegin[sos]];
    761                 type = SosType[sos];
    762                 CbcObject *sosObject = new CbcSOS(pCoin->cbc, count, which, NULL, 0, type);
    763                 pCoin->cbc->addObjects(1, &sosObject);
    764                 delete sosObject;
    765         }
    766388        return SOLV_CALL_SUCCESS;
    767389}
     
    783405}
    784406
    785 
    786 
    787 SOLVAPI int SOLVCALL CoinUnloadProblem(HPROB hProb)
    788 {
    789    PCOIN pCoin = (PCOIN)hProb;
    790        
    791         if (pCoin) {
    792                 delete pCoin->msghandler;
    793                 delete pCoin->iterhandler;
    794                 delete pCoin->nodehandler;
    795                 delete pCoin->clp;
    796                 delete pCoin->clp_presolve;
    797                 delete pCoin->cbc;
    798 
    799                 coinClearProblemObject(pCoin->pProblem);
    800                 coinClearResultObject(pCoin->pResult);
    801         }
    802         free(pCoin);
    803         pCoin = NULL;
    804         return SOLV_CALL_SUCCESS;
    805 }
    806407
    807408
     
    855456                }
    856457                if (pProblem->MatrixBegin[pProblem->ColCount] != pProblem->NZCount) {
    857                         return 100+pProblem->MatrixBegin[pProblem->ColCount];
     458                        return 100 + pProblem->MatrixBegin[pProblem->ColCount];
    858459                }
    859460                for (i = 0; i < pProblem->NZCount; i++) {
     
    974575
    975576
    976 /************************************************************************/
    977 /*  Callback Handling                                                   */
    978 /************************************************************************/
    979 
    980 
    981 int coinWriteMsgLog(const char* FormatStr, ...)
    982 {
    983         va_list pVa;
    984         char strbuf[256];
    985 
    986         va_start(pVa,FormatStr);
    987         vsprintf(strbuf,FormatStr,pVa);
    988         if (global_pCoin->pSolver->MsgLogCallback) {
    989                 global_pCoin->pSolver->MsgLogCallback(strbuf);
    990         }
    991         return SOLV_CALL_SUCCESS;
    992 }
    993 
    994 
    995 int coinIterLogCallback(int IterCount, double ObjectValue, int IsFeasible, double InfeasValue)
    996 {
    997         if (!global_pCoin->pProblem->SolveAsMIP) {
    998                 if (((IterCount < 100) && ((IterCount % 10) == 0)) ||
    999                          ((IterCount % 100) == 0)) {
    1000                         if (!IsFeasible)
    1001                                 coinWriteMsgLog("Iteration: %5d  %16.8lg  %16.8lg",IterCount, ObjectValue, InfeasValue);
    1002                         else {
    1003                                 coinWriteMsgLog("Iteration: %5d  %16.8lg",IterCount, ObjectValue);
    1004                         }
    1005                 }
    1006         }
    1007         if (global_pCoin->pSolver->IterCallback) {
    1008                 global_pCoin->pSolver->IterCallback(IterCount, ObjectValue, IsFeasible, InfeasValue);
    1009         }
    1010         return SOLV_CALL_SUCCESS;
    1011 }
    1012 
    1013 
    1014 int coinNodeLogCallback(int IterCount, int NodeCount, double BestBound, double BestObject, int IsMipImproved)
    1015 {
    1016         if ((NodeCount > 0) && (((NodeCount % 100) == 0) || (IsMipImproved))) {
    1017                 coinWriteMsgLog("Node: %5d  %s  %16.8lg  %16.8lg",
    1018                                    NodeCount, (IsMipImproved) ? "*" : " ", BestBound, BestObject);
    1019         }
    1020         if (global_pCoin->pSolver->MipNodeCallback) {
    1021                 global_pCoin->pSolver->MipNodeCallback(IterCount, NodeCount, BestBound, BestObject, IsMipImproved);
    1022         }
    1023         return SOLV_CALL_SUCCESS;
    1024 }
    1025 
    1026 
    1027 
    1028577
    1029578SOLVAPI int SOLVCALL CoinSetMsgLogCallback(HPROB hProb, MSGLOGCALLBACK MsgLogCallback)
     
    1032581
    1033582        pCoin->pSolver->MsgLogCallback = MsgLogCallback;
    1034         delete pCoin->msghandler;
    1035         pCoin->msghandler = new CBMessageHandler();
    1036         pCoin->msghandler->setCallback(MsgLogCallback);
    1037         pCoin->msghandler->setLogLevel(CoinGetIntOption(hProb, COIN_INT_LOGLEVEL));
    1038         if (pCoin->clp) pCoin->clp->passInMessageHandler(pCoin->msghandler);
    1039         if (pCoin->cbc) pCoin->cbc->passInMessageHandler(pCoin->msghandler);
    1040         if (pCoin->osi) pCoin->osi->passInMessageHandler(pCoin->msghandler);
    1041         return SOLV_CALL_SUCCESS;
    1042 }
    1043 
    1044 
     583        return SOLV_CALL_SUCCESS;
     584}
    1045585
    1046586SOLVAPI int SOLVCALL CoinSetIterCallback(HPROB hProb, ITERCALLBACK IterCallback)
     
    1049589
    1050590        pCoin->pSolver->IterCallback = IterCallback;
    1051         delete pCoin->iterhandler;
    1052         pCoin->iterhandler = new CBIterHandler(pCoin->clp);
    1053         pCoin->iterhandler->setIterCallback(IterCallback);
    1054         if (pCoin->clp) pCoin->clp->passInEventHandler(pCoin->iterhandler);
    1055         return SOLV_CALL_SUCCESS;
    1056 }
    1057 
     591        return SOLV_CALL_SUCCESS;
     592}
    1058593
    1059594SOLVAPI int SOLVCALL CoinSetMipNodeCallback(HPROB hProb, MIPNODECALLBACK MipNodeCallback)
     
    1062597
    1063598        pCoin->pSolver->MipNodeCallback = MipNodeCallback;
    1064         delete pCoin->nodehandler;
    1065 
    1066         //JPF: pCoin->nodehandler = new CBNodeHandler(pCoin->clp);
    1067         pCoin->nodehandler = new CBNodeHandler(pCoin->cbc);
    1068 
    1069         pCoin->nodehandler->setCallback(MipNodeCallback);
    1070 #ifdef NEW_STYLE_CBCMAIN
    1071         if (CoinGetIntOption(hProb, COIN_INT_MIPUSECBCMAIN)) {
    1072                 if (pCoin->cbc) pCoin->cbc->passInEventHandler(pCoin->nodehandler);
    1073                 }
    1074         else
    1075 #endif
    1076         {
    1077                 if (pCoin->cbc) pCoin->cbc->passInEventHandler(pCoin->nodehandler);
    1078         }
    1079         return SOLV_CALL_SUCCESS;
    1080 }
    1081 
    1082 
    1083 
    1084 /************************************************************************/
    1085 /*  Option Setting                                                      */
    1086 /************************************************************************/
    1087 
    1088 
    1089 int coinSetClpOptions(HPROB hProb)
    1090 {
    1091         PCOIN pCoin = (PCOIN)hProb;
    1092         ClpSolve::SolveType method;
    1093         ClpSolve::PresolveType presolve;
    1094 
    1095         /* check if it has been changed, leave alone otherwise */
    1096         if (CoinGetOptionChanged(hProb, COIN_INT_SCALING))                      pCoin->clp->scaling(CoinGetIntOption(hProb,COIN_INT_SCALING));
    1097         if (CoinGetOptionChanged(hProb, COIN_INT_PERTURBATION))         pCoin->clp->setPerturbation(CoinGetIntOption(hProb, COIN_INT_PERTURBATION));
    1098 
    1099         if (CoinGetOptionChanged(hProb, COIN_REAL_MAXSECONDS))          pCoin->clp->setMaximumSeconds(CoinGetRealOption(hProb, COIN_REAL_MAXSECONDS));
    1100         if (CoinGetOptionChanged(hProb, COIN_INT_MAXITER))                      pCoin->clp->setMaximumIterations(CoinGetIntOption(hProb, COIN_INT_MAXITER));
    1101 
    1102         if (CoinGetOptionChanged(hProb, COIN_REAL_PRIMALOBJLIM))        pCoin->clp->setPrimalObjectiveLimit(CoinGetRealOption(hProb, COIN_REAL_PRIMALOBJLIM));
    1103         if (CoinGetOptionChanged(hProb, COIN_REAL_DUALOBJLIM))          pCoin->clp->setDualObjectiveLimit(CoinGetRealOption(hProb, COIN_REAL_DUALOBJLIM));
    1104         if (CoinGetOptionChanged(hProb, COIN_REAL_PRIMALOBJTOL))        pCoin->clp->setPrimalTolerance(CoinGetRealOption(hProb, COIN_REAL_PRIMALOBJTOL));
    1105         if (CoinGetOptionChanged(hProb, COIN_REAL_DUALOBJTOL))          pCoin->clp->setDualTolerance(CoinGetRealOption(hProb, COIN_REAL_DUALOBJTOL));
    1106 
    1107         if (CoinGetOptionChanged(hProb, COIN_INT_PRIMALPIVOTALG)) {
    1108                 ClpPrimalColumnSteepest primalSteepest(CoinGetIntOption(hProb, COIN_INT_PRIMALPIVOTALG));
    1109                 pCoin->clp->setPrimalColumnPivotAlgorithm(primalSteepest);
    1110         }
    1111 
    1112         if (CoinGetOptionChanged(hProb, COIN_INT_DUALPIVOTALG)) {
    1113                 ClpDualRowSteepest dualSteepest(CoinGetIntOption(hProb, COIN_INT_DUALPIVOTALG));
    1114                 pCoin->clp->setDualRowPivotAlgorithm(dualSteepest);
    1115         }
    1116 
    1117         if (CoinGetOptionChanged(hProb, COIN_INT_CRASHIND)) {
    1118                 if (CoinGetIntOption(hProb, COIN_INT_CRASHIND)) {
    1119                         pCoin->clp->crash(CoinGetRealOption(hProb, COIN_REAL_CRASHGAP),
    1120                                                                 CoinGetIntOption(hProb, COIN_INT_CRASHPIVOT));
    1121                 }
    1122         }
    1123 
    1124         if (CoinGetOptionChanged(hProb, COIN_INT_SOLVEMETHOD)) {
    1125                 switch (CoinGetIntOption(hProb,COIN_INT_SOLVEMETHOD)) {
    1126                         case 0: method = ClpSolve::useDual;                             break;
    1127                         case 1: method = ClpSolve::usePrimal;                   break;
    1128                         case 2: method = ClpSolve::usePrimalorSprint;   break;
    1129                         case 3: method = ClpSolve::useBarrier;                  break;
    1130                         case 4: method = ClpSolve::useBarrierNoCross;   break;
    1131                         case 5: method = ClpSolve::automatic;                   break;
    1132                         default: method = ClpSolve::usePrimal;
    1133                 }
    1134                 pCoin->clp->setSolveType(method);   //ClpSolve::usePrimal
    1135         }
    1136 
    1137         if (CoinGetOptionChanged(hProb, COIN_INT_PRESOLVETYPE)) {   
    1138                 switch (CoinGetIntOption(hProb,COIN_INT_PRESOLVETYPE)) {
    1139                         case 0: presolve = ClpSolve::presolveOn;                 break;
    1140                         case 1: presolve = ClpSolve::presolveOff;                break;
    1141                         case 2: presolve = ClpSolve::presolveNumber;     break;
    1142                         default: presolve = ClpSolve::presolveOn;
    1143                 }
    1144                 pCoin->clp_presolve->setPresolveType(presolve);   //ClpSolve::presolveOn
    1145         }
    1146         return 1;
    1147 }
    1148 
    1149 
    1150 int coinSetCbcOptions(HPROB hProb)
    1151 {
    1152         PCOIN pCoin = (PCOIN)hProb;
    1153 
    1154         if (!pCoin->cbc) {
    1155                 return 0;
    1156         }
    1157         if (CoinGetOptionChanged(hProb, COIN_INT_MIPMAXNODES))          pCoin->cbc->setMaximumNodes(CoinGetIntOption(hProb, COIN_INT_MIPMAXNODES));
    1158         if (CoinGetOptionChanged(hProb, COIN_INT_MIPMAXSOL))            pCoin->cbc->setMaximumSolutions(CoinGetIntOption(hProb, COIN_INT_MIPMAXSOL));
    1159         if (CoinGetOptionChanged(hProb, COIN_REAL_MIPMAXSEC))           pCoin->cbc->setDblParam(CbcModel::CbcMaximumSeconds,CoinGetRealOption(hProb, COIN_REAL_MIPMAXSEC));
    1160 
    1161         if (CoinGetOptionChanged(hProb, COIN_INT_MIPFATHOMDISC))        pCoin->cbc->setIntParam(CbcModel::CbcFathomDiscipline,CoinGetIntOption(hProb, COIN_INT_MIPFATHOMDISC));
    1162 
    1163         // JPF commented: pCoin->cbc->setHotstartStrategy(CoinGetIntOption(hProb, COIN_INT_MIPHOTSTART));
    1164         //              pCoin->cbc->setForcePriority(CoinGetIntOption(hProb, COIN_INT_MIPFORCEPRIOR));
    1165 
    1166         if (CoinGetOptionChanged(hProb, COIN_INT_MIPMINIMUMDROP))       pCoin->cbc->setMinimumDrop(CoinGetIntOption(hProb, COIN_INT_MIPMINIMUMDROP));
    1167         if (CoinGetOptionChanged(hProb, COIN_INT_MIPMAXPASSROOT))       pCoin->cbc->setMaximumCutPassesAtRoot(CoinGetIntOption(hProb, COIN_INT_MIPMAXPASSROOT));
    1168         if (CoinGetOptionChanged(hProb, COIN_INT_MIPMAXCUTPASS))        pCoin->cbc->setMaximumCutPasses(CoinGetIntOption(hProb, COIN_INT_MIPMAXCUTPASS));
    1169         if (CoinGetOptionChanged(hProb, COIN_INT_MIPSTRONGBRANCH))      pCoin->cbc->setNumberStrong(CoinGetIntOption(hProb, COIN_INT_MIPSTRONGBRANCH));
    1170         if (CoinGetOptionChanged(hProb, COIN_INT_MIPSCANGLOBCUTS))      pCoin->cbc->setHowOftenGlobalScan(CoinGetIntOption(hProb, COIN_INT_MIPSCANGLOBCUTS));
    1171 
    1172         if (CoinGetOptionChanged(hProb, COIN_REAL_MIPINTTOL))           pCoin->cbc->setIntegerTolerance(CoinGetRealOption(hProb, COIN_REAL_MIPINTTOL));
    1173         if (CoinGetOptionChanged(hProb, COIN_REAL_MIPINFWEIGHT))        pCoin->cbc->setInfeasibilityWeight(CoinGetRealOption(hProb, COIN_REAL_MIPINFWEIGHT));
    1174         if (CoinGetOptionChanged(hProb, COIN_REAL_MIPCUTOFF))           pCoin->cbc->setDblParam(CbcModel::CbcCutoffIncrement,CoinGetRealOption(hProb, COIN_REAL_MIPCUTOFF));
    1175         if (CoinGetOptionChanged(hProb, COIN_REAL_MIPABSGAP))           pCoin->cbc->setAllowableGap(CoinGetRealOption(hProb, COIN_REAL_MIPABSGAP));
    1176         if (CoinGetOptionChanged(hProb, COIN_REAL_MIPFRACGAP))          pCoin->cbc->setAllowableFractionGap(CoinGetRealOption(hProb, COIN_REAL_MIPFRACGAP));
    1177         return 1;
    1178 }
    1179 
    1180 
    1181 int coinSetCglOptions(HPROB hProb)
    1182 {
    1183         PCOIN pCoin = (PCOIN)hProb;
    1184 
    1185         /* see CbcModel.hpp has commments on calling cuts */
    1186         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_PROBING)) {
    1187                 pCoin->probing = new CglProbing();
    1188                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPPROBE_MODE))        pCoin->probing->setMode(CoinGetIntOption(hProb, COIN_INT_MIPPROBE_MODE));
    1189                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPPROBE_USEOBJ))      pCoin->probing->setUsingObjective(CoinGetIntOption(hProb, COIN_INT_MIPPROBE_USEOBJ) ? true : false);
    1190                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPPROBE_MAXPASS))     pCoin->probing->setMaxPass(CoinGetIntOption(hProb, COIN_INT_MIPPROBE_MAXPASS));
    1191                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPPROBE_MAXPROBE))    pCoin->probing->setMaxProbe(CoinGetIntOption(hProb, COIN_INT_MIPPROBE_MAXPROBE));
    1192                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPPROBE_MAXLOOK))     pCoin->probing->setMaxLook(CoinGetIntOption(hProb, COIN_INT_MIPPROBE_MAXLOOK));
    1193                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPPROBE_ROWCUTS))     pCoin->probing->setRowCuts(CoinGetIntOption(hProb, COIN_INT_MIPPROBE_ROWCUTS));
    1194                 pCoin->cbc->addCutGenerator(pCoin->probing,CoinGetIntOption(hProb, COIN_INT_MIPPROBE_FREQ),"Probing");
    1195         }
    1196 
    1197         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_GOMORY)) {
    1198                 pCoin->gomory = new CglGomory();
    1199                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPGOMORY_LIMIT))      pCoin->gomory->setLimit(CoinGetIntOption(hProb, COIN_INT_MIPGOMORY_LIMIT));
    1200                 if (CoinGetOptionChanged(hProb, COIN_REAL_MIPGOMORY_AWAY))      pCoin->gomory->setAway(CoinGetRealOption(hProb, COIN_REAL_MIPGOMORY_AWAY));
    1201                 pCoin->cbc->addCutGenerator(pCoin->gomory,CoinGetIntOption(hProb, COIN_INT_MIPGOMORY_FREQ),"Gomory");
    1202         }
    1203 
    1204         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_KNAPSACK)) {
    1205                 pCoin->knapsack = new CglKnapsackCover();
    1206                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPKNAPSACK_MAXIN))    pCoin->knapsack->setMaxInKnapsack(CoinGetIntOption(hProb, COIN_INT_MIPKNAPSACK_MAXIN));
    1207                 pCoin->cbc->addCutGenerator(pCoin->knapsack,CoinGetIntOption(hProb, COIN_INT_MIPKNAPSACK_FREQ),"Knapsack");
    1208         }
    1209 
    1210         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_ODDHOLE)) {
    1211                 pCoin->oddhole= new CglOddHole();
    1212                 if (CoinGetOptionChanged(hProb, COIN_REAL_MIPODDHOLE_MINVIOL))  pCoin->oddhole->setMinimumViolation(CoinGetRealOption(hProb, COIN_REAL_MIPODDHOLE_MINVIOL));
    1213                 if (CoinGetOptionChanged(hProb, COIN_REAL_MIPODDHOLE_MINVIOLPER))       pCoin->oddhole->setMinimumViolationPer(CoinGetRealOption(hProb, COIN_REAL_MIPODDHOLE_MINVIOLPER));
    1214                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPODDHOLE_MAXENTRIES))        pCoin->oddhole->setMaximumEntries(CoinGetIntOption(hProb, COIN_INT_MIPODDHOLE_MAXENTRIES));
    1215                 pCoin->cbc->addCutGenerator(pCoin->oddhole,CoinGetIntOption(hProb, COIN_INT_MIPODDHOLE_FREQ),"OddHole");
    1216         }
    1217 
    1218         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_CLIQUE)) {
    1219                 pCoin->clique= new CglClique(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_PACKING) ? true : false);
    1220                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_STAR))               pCoin->clique->setDoStarClique(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_STAR) ? true : false);
    1221                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_STARMETHOD)) pCoin->clique->setStarCliqueNextNodeMethod((CglClique::scl_next_node_method)CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_STARMETHOD));
    1222                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_STARMAXLEN)) pCoin->clique->setStarCliqueCandidateLengthThreshold(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_STARMAXLEN));
    1223                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_STARREPORT)) pCoin->clique->setStarCliqueReport(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_STARREPORT) ? true : false);
    1224                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_ROW))                pCoin->clique->setDoRowClique(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_ROW) ? true : false);
    1225                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_ROWMAXLEN))  pCoin->clique->setRowCliqueCandidateLengthThreshold(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_ROWMAXLEN));
    1226                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPCLIQUE_ROWREPORT))  pCoin->clique->setRowCliqueReport(CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_ROWREPORT) ? true : false);
    1227                 if (CoinGetOptionChanged(hProb, COIN_REAL_MIPCLIQUE_MINVIOL))   pCoin->clique->setMinViolation(CoinGetRealOption(hProb, COIN_REAL_MIPCLIQUE_MINVIOL));
    1228                 pCoin->cbc->addCutGenerator(pCoin->clique,CoinGetIntOption(hProb, COIN_INT_MIPCLIQUE_FREQ),"Clique");
    1229         }
    1230 
    1231         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_LIFTPROJECT)) {
    1232                 pCoin->liftpro = new CglLiftAndProject();
    1233                 if (CoinGetOptionChanged(hProb, COIN_INT_MIPLIFTPRO_BETAONE))   pCoin->liftpro->setBeta(CoinGetIntOption(hProb, COIN_INT_MIPLIFTPRO_BETAONE) ? 1 : -1);
    1234                 pCoin->cbc->addCutGenerator(pCoin->liftpro,CoinGetIntOption(hProb, COIN_INT_MIPLIFTPRO_FREQ),"LiftProject");
    1235         }
    1236 
    1237         if (CoinGetIntOption(hProb, COIN_INT_MIPCUT_SIMPROUND)) {
    1238                 pCoin->rounding = new CglSimpleRounding();
    1239                 pCoin->cbc->addCutGenerator(pCoin->rounding,CoinGetIntOption(hProb, COIN_INT_MIPSIMPROUND_FREQ),"Rounding");
    1240         }
    1241         return 1;
    1242 }
    1243 
    1244 /************************************************************************/
    1245 /*  SOS Handling                                                        */
    1246 /************************************************************************/
    1247 
    1248 
    1249 int coinSetupSosObject(HPROB hProb)
    1250 {
    1251         PCOIN pCoin = (PCOIN)hProb;
    1252         PPROBLEM pProblem = pCoin->pProblem;
    1253         int sos, count;
    1254         int* which;
    1255         int type;
    1256 
    1257         for (sos = 0; sos < pProblem->SosCount; sos++) {
    1258                 count = pProblem->SosBegin[sos+1] - pProblem->SosBegin[sos];
    1259                 which = &pProblem->SosIndex[pProblem->SosBegin[sos]];
    1260                 type = pProblem->SosType[sos];
    1261                 CbcObject *sosObject = new CbcSOS(pCoin->cbc, count, which, NULL, 0, type);
    1262                 pCoin->cbc->addObjects(1, &sosObject);
    1263                 delete sosObject;
    1264         }
    1265         return 1;
    1266 }
     599        return SOLV_CALL_SUCCESS;
     600}
     601
    1267602
    1268603
     
    1271606/************************************************************************/
    1272607
    1273 int CbcRetrieveSolutionResults(PPROBLEM pProblem, HPROB hProb, PRESULT pResult)
    1274 {
    1275         PCOIN pCoin = (PCOIN)hProb;
    1276         const double* columnPrimal;
    1277         const double* columnDual;
    1278         const double* rowPrimal;
    1279         const double* rowDual;
    1280 
    1281         if (!pProblem->SolveAsMIP) {
    1282                 pResult->SolutionStatus = pCoin->clp->status();
    1283                 pResult->ObjectValue    = pCoin->clp->objectiveValue();
    1284                 pResult->MipBestBound   = 0.0;
    1285                 pResult->IterCount      = pCoin->clp->numberIterations();
    1286                 pResult->MipNodeCount     = 0;
    1287                 }
    1288         else {
    1289                 pResult->SolutionStatus = pCoin->cbc->status();
    1290                 pResult->ObjectValue    = pCoin->cbc->getObjValue();
    1291                 pResult->MipBestBound   = pCoin->cbc->getBestPossibleObjValue();
    1292                 pResult->IterCount      = pCoin->cbc->getIterationCount();
    1293                 pResult->MipNodeCount   = pCoin->cbc->getNodeCount();
    1294         }
    1295 
    1296         switch (pResult->SolutionStatus) {
    1297                 case 0: strcpy(pResult->SolutionText, "Optimal solution found");                break;
    1298                 case 1: strcpy(pResult->SolutionText, "Problem primal infeasible");     break;
    1299                 case 2: strcpy(pResult->SolutionText, "Problem dual infeasible");               break;
    1300                 case 3: strcpy(pResult->SolutionText, "Stopped on iterations");                 break;
    1301                 case 4: strcpy(pResult->SolutionText, "Stopped due to errors");                 break;
    1302                 case 5: strcpy(pResult->SolutionText, "Stopped by user");               break;
    1303                 default:
    1304                         sprintf(pResult->SolutionText, "Unknown CBC solution status (%d)", pResult->SolutionStatus);
    1305                         break;
    1306         }
    1307 
    1308         if (!pProblem->SolveAsMIP) {
    1309                 columnPrimal = pCoin->clp->primalColumnSolution();
    1310                 columnDual = pCoin->clp->dualColumnSolution();
    1311                 rowPrimal = pCoin->clp->primalRowSolution();
    1312                 rowDual = pCoin->clp->dualRowSolution();
    1313                 pResult->ColActivity = (double*) malloc(pProblem->ColCount * sizeof(double));
    1314                 pResult->ReducedCost = (double*) malloc(pProblem->ColCount * sizeof(double));
    1315                 pResult->SlackValues = (double*) malloc(pProblem->RowCount * sizeof(double));
    1316                 pResult->ShadowPrice = (double*) malloc(pProblem->RowCount * sizeof(double));
    1317                 if (!pResult->ColActivity ||
    1318                         !pResult->ReducedCost ||
    1319                         !pResult->SlackValues ||
    1320                         !pResult->ShadowPrice) {
    1321                         return SOLV_CALL_FAILED;
    1322                 }
    1323                 memcpy(pResult->ColActivity, columnPrimal, pProblem->ColCount * sizeof(double));
    1324                 memcpy(pResult->ReducedCost, columnDual, pProblem->ColCount * sizeof(double));
    1325                 memcpy(pResult->SlackValues, rowPrimal, pProblem->RowCount * sizeof(double));
    1326                 memcpy(pResult->ShadowPrice, rowDual, pProblem->RowCount * sizeof(double));
    1327                 }
    1328         else {
    1329                 columnPrimal = pCoin->cbc->solver()->getColSolution();
    1330                 pResult->ColActivity = (double*) malloc(pProblem->ColCount * sizeof(double));
    1331                 if (!pResult->ColActivity) {
    1332                         return SOLV_CALL_FAILED;
    1333                 }
    1334                 memcpy(pResult->ColActivity, columnPrimal, pProblem->ColCount * sizeof(double));
    1335         }
    1336         return SOLV_CALL_SUCCESS;
    1337 }
    1338 
    1339 
     608
     609SOLVAPI int SOLVCALL CoinOptimizeProblem(HPROB hProb, int Method)
     610{               
     611        PCOIN pCoin = (PCOIN)hProb;
     612
     613        return CbcOptimizeProblem(pCoin->pProblem, pCoin->pResult, pCoin->pSolver, Method);
     614}
     615
     616/*
    1340617extern int CbcOrClpRead_mode;
    1341618
     
    1387664}
    1388665
    1389 
     666*/
    1390667
    1391668/************************************************************************/
     
    1536813        switch (FileType) {
    1537814                case SOLV_FILE_MPS:             
    1538                         pCoin->clp->readMps(ReadFilename, 1, 0);   
    1539                         break;
     815                        return CbcReadMpsFile(pCoin->pProblem, ReadFilename);
    1540816
    1541817                case SOLV_FILE_LP:
     
    1557833        switch (FileType) {
    1558834                case SOLV_FILE_MPS:             
    1559                         pCoin->osi->writeMps(WriteFilename, "", pCoin->pProblem->ObjectSense);   
    1560                         break;
     835                        return CbcWriteMpsFile(pCoin->pProblem, WriteFilename);   
    1561836
    1562837                case SOLV_FILE_LP:
     
    1588863
    1589864
    1590 
    1591 /************************************************************************/
    1592 /*  Option Table                                                        */
    1593 /************************************************************************/
    1594 
    1595 #define OPTIONCOUNT    68
    1596 
    1597 
    1598 SOLVOPTINFO OptionTable[OPTIONCOUNT] = {
    1599 
    1600         {"SolveMethod",            "SolveMethod",  GRP_SIMPLEX,        0,        0,      0,       5,  OPT_LIST,   0,   COIN_INT_SOLVEMETHOD},
    1601       /*enum SolveType { useDual=0, usePrimal, usePrimalorSprint, useBarrier, useBarrierNoCross, automatic*/
    1602         {"PresolveType",           "Presolve",     GRP_SIMPLEX,        0,        0,      0,       2,  OPT_LIST,   0,   COIN_INT_PRESOLVETYPE},
    1603       /*enum PresolveType { presolveOn=0, presolveOff, presolveNumber }; */
    1604         {"Scaling",                "Scaling",      GRP_SIMPLEX,        3,        3,      0,       4,  OPT_LIST,   0,   COIN_INT_SCALING},
    1605       /* Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */
    1606         {"Perturbation",           "Perturb",      GRP_SIMPLEX,      100,      100,      0,     100,  OPT_INT,    0,   COIN_INT_PERTURBATION},
    1607       /* 0 - Off, 50 - On, 100 - Only if clp stalls */
    1608         {"PrimalColPivotAlg",      "PrimPivAlg",   GRP_SIMPLEX,        1,        1,      0,       4,  OPT_LIST,   0,   COIN_INT_PRIMALPIVOTALG},
    1609       /*0 is exact devex, 1 full steepest, 2 is partial exact devex
    1610         3 switches between 0 and 2 depending on factorization
    1611         4 starts as partial dantzig/devex but then may switch between 0 and 2.*/
    1612         {"DualRowPivotAlg",        "DualPivAlg",   GRP_SIMPLEX,        1,        1,      0,       3,  OPT_LIST,   0,   COIN_INT_DUALPIVOTALG},
    1613       /*0 is uninitialized, 1 full, 2 is partial uninitialized,
    1614         3 starts as 2 but may switch to 1.*/
    1615         {"LogLevel",               "LogLevel",     GRP_LOGFILE,        1,        1,      0,       4,  OPT_LIST,   0,   COIN_INT_LOGLEVEL},
    1616         {"MaxIterations",          "MaxIter",      GRP_LIMITS,  99999999, 99999999,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MAXITER},
    1617         {"MaxSeconds",             "MaxSeconds",   GRP_LIMITS,      -1.0,     -1.0,   -1.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_MAXSECONDS},
    1618 
    1619         {"CrashInd",               "CrashInd",     GRP_SIMPLEX,        0,        0,      0,       1,  OPT_ONOFF,  0,   COIN_INT_CRASHIND},
    1620         {"CrashPivot",             "CrashPivot",   GRP_SIMPLEX,        0,        0,     -1,       2,  OPT_LIST,   0,   COIN_INT_CRASHPIVOT},
    1621         {"CrashGap",               "CrashGap",     GRP_SIMPLEX,   1000.0,   1000.0,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_CRASHGAP},
    1622         {"PrimalObjectLimit",      "PrimalObjLim", GRP_SIMPLEX,  MAXREAL,  MAXREAL,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_PRIMALOBJLIM},
    1623         {"DualObjectLimit",        "DualObjLim",   GRP_SIMPLEX,  MAXREAL,  MAXREAL,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_DUALOBJLIM},
    1624         {"PrimalTolerance",        "PrimalTol",    GRP_SIMPLEX,     1e-7,     1e-7,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_PRIMALOBJTOL},
    1625         {"DualTolerance",          "DualTol",      GRP_SIMPLEX,     1e-7,     1e-7,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_DUALOBJTOL},
    1626 
    1627         {"MipMaxNodes",            "MipMaxNodes",  GRP_LIMITS,   9999999,  9999999,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPMAXNODES},
    1628         {"MipMaxSolutions",        "MipMaxSol",    GRP_LIMITS,   9999999,  9999999,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPMAXSOL},
    1629         {"MipMaxSeconds",          "MipMaxSec",    GRP_LIMITS,     1e100,    1e100,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_MIPMAXSEC},
    1630 
    1631         {"MipFathomDiscipline",    "FathomDisc",   GRP_MIPSTRAT,       0,        0,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPFATHOMDISC},
    1632         {"MipHotStart",            "HotStart",     GRP_MIPSTRAT,       0,        0,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPHOTSTART},
    1633 //      {"MipForcePriority",       "ForcePrior",   GRP_MIPSTRAT,      -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPFORCEPRIOR},
    1634         {"MipMinimumDrop",         "MinimumDrop",  GRP_MIPSTRAT,    1e-4,     1e-4,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPMINIMUMDROP},
    1635         {"MipMaxCutPasses",        "MaxCutPass",   GRP_MIPSTRAT,       2,        2,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPMAXCUTPASS},
    1636         {"MipMaxCutPassAtRoot",    "MaxPassRoot",  GRP_MIPSTRAT,      50,       50,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPMAXPASSROOT},
    1637         {"MipStrongBranching",     "StrongBranch", GRP_MIPSTRAT,       5,        5,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPSTRONGBRANCH},
    1638         {"MipScanGlobalCuts",      "ScanGlobCuts", GRP_MIPSTRAT,       1,        1,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPSCANGLOBCUTS},
    1639 
    1640         {"MipIntegerTolerance",    "MipIntTol",    GRP_MIPTOL,      1e-6,     1e-6,    0.0,     1.0,  OPT_REAL,   0,   COIN_REAL_MIPINTTOL},
    1641         {"MipInfeasWeight",        "MipInfWeight", GRP_MIPTOL,       0.0,      0.0,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_MIPINFWEIGHT},
    1642         {"MipCutoffIncrement",     "MipCutIncr",   GRP_MIPTOL,      1e-5,     1e-5,    0.0,     1.0,  OPT_REAL,   0,   COIN_REAL_MIPCUTOFF},
    1643         {"MipAllowableGap",        "MipAbsGap",    GRP_MIPTOL,     1e-10,    1e-10,    0.0, MAXREAL,  OPT_REAL,   0,   COIN_REAL_MIPABSGAP},
    1644         {"MipFractionalGap",       "MipFracGap",   GRP_MIPTOL,     1e-10,    1e-10,    0.0,     1.0,  OPT_REAL,   0,   COIN_REAL_MIPFRACGAP},
    1645 
    1646         /* Probing */
    1647         {"MipCutProbing",          "CutProbing",   GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_PROBING},
    1648         {"MipProbeFrequency",      "ProbeFreq",    GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPPROBE_FREQ},
    1649         {"MipProbeMode",           "ProbeMode",    GRP_MIPCUTS,        1,        1,      0,       2,  OPT_LIST,   0,   COIN_INT_MIPPROBE_MODE},
    1650         {"MipProbeUseObjective",   "UseObject",    GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPPROBE_USEOBJ},
    1651         {"MipProbeMaxPass",        "MaxPass",      GRP_MIPCUTS,        3,        3,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPPROBE_MAXPASS},
    1652         {"MipProbeMaxProbe",       "MaxProbe",     GRP_MIPCUTS,      100,      100,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPPROBE_MAXPROBE},
    1653         {"MipProbeMaxLook",        "MaxLook",      GRP_MIPCUTS,       50,       50,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPPROBE_MAXLOOK},
    1654         {"MipProbeRowCuts",        "RowCuts",      GRP_MIPCUTS,        3,        3,      0,       3,  OPT_LIST,   0,   COIN_INT_MIPPROBE_ROWCUTS},
    1655 
    1656         /* Gomory cuts */
    1657         {"MipCutGomory",           "CutGomory",    GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_GOMORY},
    1658         {"MipGomoryFrequency",     "GomoryFreq",   GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPGOMORY_FREQ},
    1659         {"MipGomoryLimit",         "GomoryLimit",  GRP_MIPCUTS,       50,       50,      1,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPGOMORY_LIMIT},
    1660         {"MipGomoryAway",          "GomoryAway",   GRP_MIPCUTS,     0.05,     0.05, 0.0001,     0.5,  OPT_REAL,   0,   COIN_REAL_MIPGOMORY_AWAY},
    1661 
    1662         /* Knapsack cuts */
    1663         {"MipCutKnapsack",         "CutKnapsack",  GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_KNAPSACK},
    1664         {"MipKnapsackFrequency",   "KrapsackFreq", GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPKNAPSACK_FREQ},
    1665         {"MipKnapsackMaxIn",       "KnapsackMaxIn",GRP_MIPCUTS,       50,       50,      1,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPKNAPSACK_MAXIN},
    1666 
    1667         /* Oddhole cuts */
    1668         {"MipCutOddHole",          "CutOddHole",   GRP_MIPCUTS,        0,        0,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_ODDHOLE},
    1669         {"MipOddHoleFrequency",    "OddHoleFreq",  GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPODDHOLE_FREQ},
    1670         {"MipOddHoleMinViolation", "MinViolation", GRP_MIPCUTS,    0.001,    0.001,1.01e-8,     0.5,  OPT_REAL,   0,   COIN_REAL_MIPODDHOLE_MINVIOL},
    1671         {"MipOddHoleMinViolPer",   "MinViolPer",   GRP_MIPCUTS,   0.0003,   0.0003,1.01e-8,    0.25,  OPT_REAL,   0,   COIN_REAL_MIPODDHOLE_MINVIOLPER},
    1672         {"MipOddHoleMaxEntries",   "MaxEntries",   GRP_MIPCUTS,      100,      100,      3,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPODDHOLE_MAXENTRIES},
    1673 
    1674         /* Clique cuts */
    1675         {"MipCutClique",           "CutClique",    GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_CLIQUE},
    1676         {"MipCliqueFrequency",     "CliqueFreq",   GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPCLIQUE_FREQ},
    1677         {"MipCliquePacking",       "CliquePacking",GRP_MIPCUTS,        0,        0,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCLIQUE_PACKING},
    1678         {"MipCliqueStar",          "CliqueStar",   GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCLIQUE_STAR},
    1679         {"MipCliqueStarMethod",    "StarMethod",   GRP_MIPCUTS,        2,        2,      0,       2,  OPT_LIST,   0,   COIN_INT_MIPCLIQUE_STARMETHOD},
    1680         {"MipCliqueStarMaxLen",    "StarMaxLen",   GRP_MIPCUTS,       12,       12,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPCLIQUE_STARMAXLEN},
    1681         {"MipCliqueStarReport",    "StarReport",   GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCLIQUE_STARREPORT},
    1682         {"MipCliqueRow",           "CliqueRow",    GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCLIQUE_ROW},
    1683         {"MipCliqueRowMaxLen",     "ClqRowMaxLen", GRP_MIPCUTS,       12,       12,      0,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPCLIQUE_ROWMAXLEN},
    1684         {"MipCliqueRowReport",     "ClqRowReport", GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCLIQUE_ROWREPORT},
    1685         {"MipCliqueMinViolation",  "ClqMinViol",   GRP_MIPCUTS,     -1.0,     -1.0,-MAXREAL,MAXREAL,  OPT_REAL,   0,   COIN_REAL_MIPCLIQUE_MINVIOL},
    1686 
    1687         /* Lift and Project */
    1688         {"MipCutLiftAndProject",   "CutLiftPro",   GRP_MIPCUTS,        0,        0,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_LIFTPROJECT},
    1689         {"MipLiftCoverFrequency",  "LiftProFreq",  GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPLIFTPRO_FREQ},
    1690         {"MipLiftCoverBetaOne",    "LiftProBeta",  GRP_MIPCUTS,        1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPLIFTPRO_BETAONE},
    1691 
    1692         /* Simple Rounding */
    1693         {"MipCutSimpleRounding",   "CutSimpRound", GRP_MIPCUTS,        0,        0,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPCUT_SIMPROUND},
    1694         {"MipSimpleRoundFrequency","SimpRoundFreq",GRP_MIPCUTS,       -1,       -1,-MAXINT,  MAXINT,  OPT_INT,    0,   COIN_INT_MIPSIMPROUND_FREQ},
    1695 
    1696         {"MipUseCbcMain",          "UseCbcMain",   GRP_MIPSTRAT,       1,        1,      0,       1,  OPT_ONOFF,  0,   COIN_INT_MIPUSECBCMAIN}
    1697         };
    1698 
    1699 
    1700 
    1701865/************************************************************************/
    1702866/*  Option Handling                                                     */
     
    1706870SOLVAPI int SOLVCALL CoinGetOptionCount(HPROB hProb)
    1707871{
    1708         return OPTIONCOUNT;
     872        PCOIN pCoin = (PCOIN)hProb;
     873
     874        return coinGetOptionCount(pCoin->pSolver);
     875}
     876
     877SOLVAPI int SOLVCALL CoinGetOptionID(HPROB hProb, int OptionNr)
     878{
     879        PCOIN pCoin = (PCOIN)hProb;
     880
     881        return coinGetOptionID(pCoin->pSolver, OptionNr);
     882}
     883
     884SOLVAPI int    SOLVCALL CoinLocateOptionID(HPROB hProb, int OptionID)
     885{
     886        PCOIN pCoin = (PCOIN)hProb;
     887
     888        return coinLocateOptionID(pCoin->pSolver, OptionID);
    1709889}
    1710890
     
    1712892SOLVAPI int SOLVCALL CoinGetOptionInfo(HPROB hProb, int OptionNr, int* OptionID, int* GroupType, int* OptionType)
    1713893{
    1714         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1715                 return SOLV_CALL_FAILED;
    1716         }
    1717         if (OptionID)   *OptionID = OptionTable[OptionNr].OptionID;
    1718         if (OptionType) *OptionType = OptionTable[OptionNr].OptionType;
    1719         if (GroupType)  *GroupType = OptionTable[OptionNr].GroupType;
    1720         return SOLV_CALL_SUCCESS;
     894        PCOIN pCoin = (PCOIN)hProb;
     895        int optionID;
     896
     897        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     898        if (OptionID)   *OptionID = optionID;
     899        if (OptionType) *OptionType = coinGetOptionType(pCoin->pSolver, optionID);
     900        if (GroupType)  *GroupType = coinGetOptionGroup(pCoin->pSolver, optionID);
     901        return SOLV_CALL_SUCCESS;
     902}
     903
     904
     905
     906SOLVAPI int SOLVCALL CoinGetOptionType(HPROB hProb, int OptionID)
     907{
     908        PCOIN pCoin = (PCOIN)hProb;
     909
     910        return coinGetOptionType(pCoin->pSolver, OptionID);
     911}
     912
     913
     914SOLVAPI int SOLVCALL CoinGetOptionGroup(HPROB hProb, int OptionID)
     915{
     916        PCOIN pCoin = (PCOIN)hProb;
     917
     918        return coinGetOptionGroup(pCoin->pSolver, OptionID);
     919}
     920
     921
     922SOLVAPI int    SOLVCALL CoinLocateOptionName(HPROB hProb, char* OptionName)
     923{
     924        PCOIN pCoin = (PCOIN)hProb;
     925
     926        return coinLocateOptionName(pCoin->pSolver, OptionName);
    1721927}
    1722928
     
    1724930SOLVAPI const char* SOLVCALL CoinGetOptionName(HPROB hProb, int OptionNr)
    1725931{
    1726         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1727                 return "";
    1728         }
    1729         return OptionTable[OptionNr].OptionName;
     932        PCOIN pCoin = (PCOIN)hProb;
     933        int optionID;
     934
     935        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     936        return coinGetOptionName(pCoin->pSolver, optionID);
    1730937}
    1731938
     
    1733940SOLVAPI int SOLVCALL CoinGetOptionNameBuf(HPROB hProb, int OptionNr, char* OptionName, int buflen)
    1734941{
    1735         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1736                 return SOLV_CALL_FAILED;
    1737         }
    1738         if (OptionName) {
    1739                 strncpy(OptionName, CoinGetOptionName(hProb, OptionNr), buflen-1);
    1740                 OptionName[buflen-1] = '\0';
    1741         }
    1742         return SOLV_CALL_SUCCESS;
     942        PCOIN pCoin = (PCOIN)hProb;
     943        int optionID;
     944
     945        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     946        return coinGetOptionNameBuf(pCoin->pSolver, optionID, OptionName, buflen);
    1743947}
    1744948
     
    1746950SOLVAPI const char* SOLVCALL CoinGetOptionShortName(HPROB hProb, int OptionNr)
    1747951{
    1748         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1749                 return "";
    1750         }
    1751         return OptionTable[OptionNr].ShortName;
     952        PCOIN pCoin = (PCOIN)hProb;
     953        int optionID;
     954
     955        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     956        return coinGetOptionShortName(pCoin->pSolver, optionID);
    1752957}
    1753958
     
    1755960SOLVAPI int SOLVCALL CoinGetOptionShortNameBuf(HPROB hProb, int OptionNr, char* ShortName, int buflen)
    1756961{
    1757         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1758                 return SOLV_CALL_FAILED;
    1759         }
    1760         if (ShortName) {
    1761                 strncpy(ShortName, CoinGetOptionShortName(hProb, OptionNr), buflen-1);
    1762                 ShortName[buflen-1] = '\0';
    1763         }
    1764         return SOLV_CALL_SUCCESS;
     962        PCOIN pCoin = (PCOIN)hProb;
     963        int optionID;
     964
     965        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     966        return coinGetOptionShortNameBuf(pCoin->pSolver, optionID, ShortName, buflen);
    1765967}
    1766968
     
    1768970SOLVAPI int SOLVCALL CoinGetIntOptionMinMax(HPROB hProb, int OptionNr, int* MinValue, int* MaxValue)
    1769971{
    1770         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1771                 return SOLV_CALL_FAILED;
    1772         }
    1773         if (MinValue)   *MinValue = ROUND(OptionTable[OptionNr].MinValue);
    1774         if (MaxValue)   *MaxValue = ROUND(OptionTable[OptionNr].MaxValue);
     972        PCOIN pCoin = (PCOIN)hProb;
     973        int optionID;
     974
     975        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     976        if (MinValue)   *MinValue = coinGetIntOptionMinValue(pCoin->pSolver, optionID);
     977        if (MaxValue)   *MaxValue = coinGetIntOptionMaxValue(pCoin->pSolver, optionID);
    1775978        return SOLV_CALL_SUCCESS;
    1776979}
     
    1779982SOLVAPI int SOLVCALL CoinGetRealOptionMinMax(HPROB hProb, int OptionNr, double* MinValue, double* MaxValue)
    1780983{
    1781         if ((OptionNr < 0) || (OptionNr >= OPTIONCOUNT)) {
    1782                 return SOLV_CALL_FAILED;
    1783         }
    1784         if (MinValue)   *MinValue = OptionTable[OptionNr].MinValue;
    1785         if (MaxValue)   *MaxValue = OptionTable[OptionNr].MaxValue;
    1786         return SOLV_CALL_SUCCESS;
    1787 }
    1788 
    1789 
    1790 int coinLocateOptionID(int OptionID)
    1791 {
    1792         int i;
    1793 
    1794         for (i = 0; i < OPTIONCOUNT; i++) {
    1795                 if (OptionID == OptionTable[i].OptionID) {
    1796                         return i;
    1797                 }
    1798         }
    1799         return -1;
    1800 }
     984        PCOIN pCoin = (PCOIN)hProb;
     985        int optionID;
     986
     987        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     988        if (MinValue)   *MinValue = coinGetRealOptionMinValue(pCoin->pSolver, optionID);
     989        if (MaxValue)   *MaxValue = coinGetRealOptionMaxValue(pCoin->pSolver, optionID);
     990        return SOLV_CALL_SUCCESS;
     991}
     992
     993
     994SOLVAPI int    SOLVCALL CoinGetIntOptionDefaultValue(HPROB hProb, int OptionID)
     995{
     996        PCOIN pCoin = (PCOIN)hProb;
     997
     998        return coinGetIntOptionDefaultValue(pCoin->pSolver, OptionID);
     999}
     1000
     1001
     1002SOLVAPI int    SOLVCALL CoinGetIntOptionMinValue(HPROB hProb, int OptionID)
     1003{
     1004        PCOIN pCoin = (PCOIN)hProb;
     1005
     1006        return coinGetIntOptionMinValue(pCoin->pSolver, OptionID);
     1007}
     1008
     1009
     1010SOLVAPI int    SOLVCALL CoinGetIntOptionMaxValue(HPROB hProb, int OptionID)
     1011{
     1012        PCOIN pCoin = (PCOIN)hProb;
     1013
     1014        return coinGetIntOptionMaxValue(pCoin->pSolver, OptionID);
     1015}
     1016
     1017
     1018
     1019SOLVAPI double SOLVCALL CoinGetRealOptionDefaultValue(HPROB hProb, int OptionID)
     1020{
     1021        PCOIN pCoin = (PCOIN)hProb;
     1022
     1023        return coinGetRealOptionDefaultValue(pCoin->pSolver, OptionID);
     1024}
     1025
     1026
     1027SOLVAPI double SOLVCALL CoinGetRealOptionMinValue(HPROB hProb, int OptionID)
     1028{
     1029        PCOIN pCoin = (PCOIN)hProb;
     1030
     1031        return coinGetRealOptionMinValue(pCoin->pSolver, OptionID);
     1032}
     1033
     1034
     1035SOLVAPI double SOLVCALL CoinGetRealOptionMaxValue(HPROB hProb, int OptionID)
     1036{
     1037        PCOIN pCoin = (PCOIN)hProb;
     1038
     1039        return coinGetRealOptionMaxValue(pCoin->pSolver, OptionID);
     1040}
     1041
     1042
    18011043
    18021044
    18031045SOLVAPI int SOLVCALL CoinGetOptionChanged(HPROB hProb, int OptionID)
    18041046{
    1805         int OptionNr;
    1806 
    1807         OptionNr = coinLocateOptionID(OptionID);
    1808         if (OptionNr < 0) {
    1809                 return 0;
    1810         }
    1811         return OptionTable[OptionNr].changed;
    1812 }
    1813 
    1814 
    1815 SOLVAPI int SOLVCALL CoinGetIntOption(HPROB hProb,int OptionID)
     1047        PCOIN pCoin = (PCOIN)hProb;
     1048
     1049        return coinGetOptionChanged(pCoin->pSolver, OptionID);
     1050}
     1051
     1052
     1053SOLVAPI int SOLVCALL CoinGetIntOption(HPROB hProb, int OptionID)
    18161054{   
    1817         int OptionNr;
    1818 
    1819         OptionNr = coinLocateOptionID(OptionID);
    1820         if (OptionNr < 0) {
    1821                 return 0;
    1822         }
    1823         if (OptionTable[OptionNr].OptionType != OPT_REAL)
    1824                 return (int)OptionTable[OptionNr].CurrentValue;
    1825         else {
    1826                 return 0;
    1827         }
     1055        PCOIN pCoin = (PCOIN)hProb;
     1056
     1057//      if (pCoin)
     1058                return coinGetIntOption(pCoin->pSolver, OptionID);
     1059//      else {
     1060//              return CbcGetIntOption(OptionID);
     1061//      }
    18281062}
    18291063       
    18301064
    18311065
    1832 SOLVAPI int SOLVCALL CoinSetIntOption(HPROB hProb,int OptionID, int IntValue)
    1833 {
    1834         int OptionNr;
    1835 
    1836         OptionNr = coinLocateOptionID(OptionID);
    1837         if (OptionNr < 0) {
    1838                 return SOLV_CALL_FAILED;
    1839         }
    1840         if (OptionTable[OptionNr].OptionType != OPT_REAL) {
    1841                 coinWriteMsgLog("%s[%d] = %d (was %d)",OptionTable[OptionNr].OptionName, OptionNr, IntValue, (int)OptionTable[OptionNr].CurrentValue);
    1842                 OptionTable[OptionNr].CurrentValue = IntValue;
    1843                 OptionTable[OptionNr].changed = 1;
    1844            return SOLV_CALL_SUCCESS;
    1845         }
    1846         return SOLV_CALL_FAILED;
    1847 }
    1848 
    1849 
    1850 
    1851 SOLVAPI double SOLVCALL CoinGetRealOption(HPROB hProb,int OptionID)
    1852 {
    1853         int OptionNr;
    1854 
    1855         OptionNr = coinLocateOptionID(OptionID);
    1856         if (OptionNr < 0) {
    1857                 return 0.0;
    1858         }
    1859         if (OptionTable[OptionNr].OptionType == OPT_REAL) {
    1860                 return OptionTable[OptionNr].CurrentValue;
    1861         }
    1862         return 0.0;
    1863 }
    1864 
    1865 
    1866 
    1867 SOLVAPI int SOLVCALL CoinSetRealOption(HPROB hProb,int OptionID, double RealValue)
    1868 {
    1869         int OptionNr;
    1870 
    1871         OptionNr = coinLocateOptionID(OptionID);
    1872         if (OptionNr < 0) {
    1873                 return SOLV_CALL_FAILED;
    1874         }
    1875         if (OptionTable[OptionNr].OptionType == OPT_REAL) {
    1876                 coinWriteMsgLog("%s[%d] = %lg (was %lg)",OptionTable[OptionNr].OptionName, OptionNr, RealValue, OptionTable[OptionNr].CurrentValue);
    1877                 OptionTable[OptionNr].CurrentValue = RealValue;
    1878                 OptionTable[OptionNr].changed = 1;
    1879            return SOLV_CALL_SUCCESS;
    1880         }
    1881         return SOLV_CALL_FAILED;
     1066SOLVAPI int SOLVCALL CoinSetIntOption(HPROB hProb, int OptionID, int IntValue)
     1067{
     1068        PCOIN pCoin = (PCOIN)hProb;
     1069
     1070        return coinSetIntOption(pCoin->pSolver, OptionID, IntValue);
     1071}
     1072
     1073
     1074
     1075SOLVAPI double SOLVCALL CoinGetRealOption(HPROB hProb, int OptionID)
     1076{
     1077        PCOIN pCoin = (PCOIN)hProb;
     1078
     1079        return coinGetRealOption(pCoin->pSolver, OptionID);
     1080}
     1081
     1082
     1083
     1084SOLVAPI int SOLVCALL CoinSetRealOption(HPROB hProb, int OptionID, double RealValue)
     1085{
     1086        PCOIN pCoin = (PCOIN)hProb;
     1087
     1088        return coinSetRealOption(pCoin->pSolver, OptionID, RealValue);
    18821089}
    18831090
     
    19301137#endif
    19311138
    1932 
    1933 
    1934 //double
    1935 // DualTolerance
    1936 // PrimalTolerance
    1937 // DualBound
    1938 // PrimalWeight (setInfeasibilityCost)
    1939 // MaxTime      (setMaximumSeconds)
    1940 // ObjScale     (setObjectiveScale)
    1941 // RhsScale     (setRhsScale)
    1942 
    1943 //int
    1944 //LogLevel      (setLogLovel/model->factorization()->messageLevel(8);)
    1945 //MaxFactor     (model->factorization()->maximumPivots(value);
    1946 //PertValue     (setPerturbation)
    1947 //MaxIteration  (setMaximumIterations)
    1948 
    1949 //AutoScale     off
    1950 //Barrier
    1951 //BiasLU        UU  (UX, LX, LL)
    1952 //Crash         off
    1953 //Direction     min
    1954 //Directory
    1955 //dualBound     1e-20, 1e12
    1956 //dualPivot     Automatic, (Dantzig, partial, Steepest)
    1957 //DualSimplex
    1958 //dualTolerance 1e-20,1e12
    1959 //Exit
    1960 //ErrorsAllowed
    1961 //FakeBound
    1962 //Help
    1963 //Idiot
    1964 //Import
    1965 //KeepNames
    1966 //LogLevel
    1967 //Maximize
    1968 //MaxFactor     1, 999999
    1969 //MaxIteration  0, 99999999
    1970 //Messages
    1971 //ObjScale      -1e20, 1e20
    1972 //PresolvePass  0, 100
    1973 //PertValue     -5000, 102, false
    1974 //Perturbation  On, off
    1975 //PlusMinus     -1, false
    1976 //Presolve      On
    1977 //PrimalPivot     Automatic, (Dantzig, partial, Steepest, change, sprint)
    1978 //PrimalSimplex
    1979 //PrimalTolerance 1e-20,1e12
    1980 //PrimalWeight    1e20, 1e20
    1981 //RhsScale        -1e20, 1.20
    1982 //Scaling         Off, Equilibrium, geometric, automatic
    1983 //MaxTime         0.0, 1e12
    1984 //SparseFactor    On, Off
    1985 //SprintCrash     -1, 500
    1986 
Note: See TracChangeset for help on using the changeset viewer.