Changeset 95


Ignore:
Timestamp:
Aug 4, 2008 11:32:29 PM (11 years ago)
Author:
bjarni
Message:

Cleaned names and layout

Location:
trunk/CoinMP/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CoinMP/src/CoinMP.cpp

    r88 r95  
    55/*  File         :  'coinmp.cpp'                                        */
    66/*                                                                      */
    7 /*  Author       :  Bjarni Kristjansson                                 */
     7/*  Version      :  1.1                                                 */
    88/*                                                                      */
    9 /*  Copyright (c) 2005-2008                     Bjarni Kristjansson     */
     9/*  Author       :  Bjarni Kristjansson, Maximal Software               */
     10/*                                                                      */
     11/*  Copyright (c) 2002-2008                     Bjarni Kristjansson     */
    1012/*                                                                      */
    1113/************************************************************************/
     
    5759#define NEW_STYLE_CBCMAIN
    5860
    59 /**************************************************************************/
     61
     62/************************************************************************/
     63/*  Solver Initialization                                               */
     64/************************************************************************/
     65
     66
     67SOLVAPI int CoinInitSolver(char *LicenseStr)
     68{
     69        return SOLV_SUCCESS;
     70}
     71
     72
     73SOLVAPI int CoinFreeSolver(void)
     74{
     75        return SOLV_SUCCESS;
     76}
     77
     78/************************************************************************/
     79/*  Solver Queries                                                      */
     80/************************************************************************/
     81
     82
     83SOLVAPI char*  CoinGetSolverName(void)
     84{
     85        return "CoinMP";
     86}
     87
     88
     89SOLVAPI char*  CoinGetVersionStr(void)
     90{
     91        return "1.1";
     92}
     93
     94
     95SOLVAPI double CoinGetVersion(void)
     96{
     97        return 1.1;
     98}
     99
     100
     101SOLVAPI int    CoinGetFeatures(void)
     102{
     103        return 0;
     104}
     105
     106
     107
     108SOLVAPI double CoinGetRealMax(void)
     109{
     110        return COIN_DBL_MAX;
     111}
     112
     113
     114/************************************************************************/
     115/*  Message Callback Handler                                            */
     116/************************************************************************/
    60117
    61118
    62119class CBMessageHandler : public CoinMessageHandler {
    63120public:
    64    void setCallback(MSGLOGCALLBACK callback);
     121        void setCallback(MSGLOGCALLBACK msgCallback);
    65122        virtual int print();
    66123private:
    67         MSGLOGCALLBACK callback_;
     124        MSGLOGCALLBACK msgCallback_;
    68125};
    69126
    70127
    71 void CBMessageHandler::setCallback(MSGLOGCALLBACK callback)
    72 {
    73   callback_ = callback;
     128void CBMessageHandler::setCallback(MSGLOGCALLBACK msgCallback)
     129{
     130  msgCallback_ = msgCallback;
    74131}
    75132
     
    77134int CBMessageHandler::print()
    78135{
    79         callback_((char *)messageBuffer());
     136        msgCallback_((char *)messageBuffer());
    80137        return CoinMessageHandler::print();
    81138}
     
    83140
    84141
    85 /**************************************************************************/
     142/************************************************************************/
     143/*  Iteration Callback Handler                                          */
     144/************************************************************************/
    86145
    87146
     
    89148
    90149public:
    91    void setIterCallback(ITERCALLBACK callback);
    92    void setNodeCallback(NODECALLBACK callback);
     150   void setIterCallback(ITERCALLBACK iterCallback);
    93151
    94152        virtual int event(Event whichEvent);
     
    110168private:
    111169        ITERCALLBACK iterCallback_;
    112         NODECALLBACK nodeCallback_;
    113170};
    114171
    115172
    116 void CBIterHandler::setIterCallback(ITERCALLBACK callback)
    117 {
    118   iterCallback_ = callback;
    119 }
    120 
    121 
    122 void CBIterHandler::setNodeCallback(NODECALLBACK callback)
    123 {
    124   nodeCallback_ = callback;
    125 }
     173void CBIterHandler::setIterCallback(ITERCALLBACK iterCallback)
     174{
     175  iterCallback_ = iterCallback;
     176}
     177
    126178
    127179
     
    148200                }
    149201        }
    150         if ((whichEvent == node) ||
    151                  (whichEvent == treeStatus) ||
    152                  (whichEvent == solution)) {
    153                 numIter = model_->getIterationCount();
    154                 objValue = model_->getObjValue();
    155                 cancelAsap = nodeCallback_(numIter, 0, 0.0, objValue, 0);
    156                 if (cancelAsap) {
    157                         return 5;
    158                 }
    159         }
    160202        return -1;
    161203}
     
    190232   iterhandler = new CBIterHandler(*this);
    191233        iterhandler->iterCallback_ = this->iterCallback_;
    192         iterhandler->nodeCallback_ = this->nodeCallback_;
    193234        return iterhandler;
    194235}
     
    196237
    197238
    198 /**************************************************************************/
     239/************************************************************************/
     240/*  Mip Node Callback Handler                                           */
     241/************************************************************************/
    199242
    200243
     
    202245
    203246public:
    204    void setCallback(NODECALLBACK callback);
     247   void setCallback(NODECALLBACK mipCodeCallback);
    205248
    206249        virtual CbcAction event(CbcEvent whichEvent);
     
    224267
    225268private:
    226         NODECALLBACK callback_;
     269        NODECALLBACK mipNodeCallback_;
    227270        int lastSolCount_;
    228271};
    229272
    230273
    231 void CBNodeHandler::setCallback(NODECALLBACK callback)
    232 {
    233   callback_ = callback;
     274void CBNodeHandler::setCallback(NODECALLBACK mipNodeCallback)
     275{
     276  mipNodeCallback_ = mipNodeCallback;
    234277  lastSolCount_ = 0;
    235278}
     
    251294                bestBound = model_->getBestPossibleObjValue();
    252295                solCount = model_->getSolutionCount();
    253                 cancelAsap = callback_(numIter, numNodes, bestBound, objValue, solCount != lastSolCount_);
     296                cancelAsap = mipNodeCallback_(numIter, numNodes, bestBound, objValue, solCount != lastSolCount_);
    254297                lastSolCount_ = solCount;
    255298                if (cancelAsap) {
     
    289332
    290333        nodehandler = new CBNodeHandler(*this);
    291         nodehandler->callback_ = this->callback_;
     334        nodehandler->mipNodeCallback_ = this->mipNodeCallback_;
    292335        nodehandler->lastSolCount_ = this->lastSolCount_;
    293336        return nodehandler;
     
    296339
    297340
    298 /**************************************************************************/
     341/************************************************************************/
     342/*  Coin Problem Info Structure                                         */
     343/************************************************************************/
     344
    299345
    300346typedef struct {
     
    303349                                CbcModel *cbc;
    304350#ifdef NEW_STYLE_CBCMAIN
    305                                 CbcModel *cbc2;
     351                                //CbcModel *cbc2;
    306352#endif
    307353                                OsiClpSolverInterface *osi;
     
    337383
    338384
    339 SOLVAPI int CoinInitSolver(char *LicenseStr)
    340 {
    341         return SOLV_SUCCESS;
    342 }
    343 
    344 
    345 SOLVAPI int CoinFreeSolver(void)
    346 {
    347         return SOLV_SUCCESS;
    348 }
    349 
    350 
    351 
    352 SOLVAPI char*  CoinGetSolverName(void)
    353 {
    354         return "CoinMP";
    355 }
    356 
    357 
    358 SOLVAPI char*  CoinGetVersionStr(void)
    359 {
    360         return "1.1";
    361 }
    362 
    363 
    364 SOLVAPI double CoinGetVersion(void)
    365 {
    366         return 1.1;
    367 }
    368 
    369 
    370 SOLVAPI int    CoinGetFeatures(void)
    371 {
    372         return 0;
    373 }
    374 
    375 
    376 
    377 SOLVAPI double CoinGetRealMax(void)
    378 {
    379         return COIN_DBL_MAX;
    380 }
    381 
    382 
    383 /**************************************************************************/
     385/************************************************************************/
     386/*  Create/Load Problem                                                 */
     387/************************************************************************/
    384388
    385389
     
    408412
    409413
    410 SOLVAPI int CoinLoadProblem(HPROB hProb, int ColCount, int RowCount, int NonZeroCount,
    411                                                                                         int RangeCount, int ObjectSense, double* ObjectCoeffs,
    412                                                                                         double* RHSValues, double* RangeValues, char* RowType,
    413                                                                                         int* MatrixBegin, int* MatrixCount, int* MatrixIndex,
    414                                                                                         double* MatrixValues, double* LowerBounds, double* UpperBounds,
    415                                                                                         double* InitValues, char** ColNames, char** RowNames)
     414SOLVAPI int CoinLoadProblem(HPROB hProb,
     415                                                        int ColCount, int RowCount, int NonZeroCount,
     416                                                        int RangeCount, int ObjectSense, double* ObjectCoeffs,
     417                                                        double* RHSValues, double* RangeValues, char* RowType,
     418                                                        int* MatrixBegin, int* MatrixCount, int* MatrixIndex,
     419                                                        double* MatrixValues, double* LowerBounds, double* UpperBounds,
     420                                                        double* InitValues, char** ColNames, char** RowNames)
    416421{
    417422   PCOIN pCoin = (PCOIN)hProb;
     
    489494                        pCoin->IsInt[i] = 1;
    490495                        pCoin->SolveAsMIP = 1;
    491                         //pCoin->cbc->solver()->setInteger(i);
    492496                }
    493497                else {
    494498                        pCoin->IsInt[i] = 0;
    495                         //pCoin->cbc->solver()->setContinuous(i);
    496499                }
    497500        }
    498501        if (pCoin->SolveAsMIP) {
    499                 //pCoin->clp->copyInIntegerInformation(pCoin->IsInt);
    500502                pCoin->cbc = new CbcModel(*pCoin->osi);
    501503                for (i = 0; i < pCoin->ColCount; i++ ) {
     
    506508#ifdef NEW_STYLE_CBCMAIN
    507509                if (CoinGetIntOption(hProb, COIN_INT_MIPUSECBCMAIN)) {
    508                         pCoin->cbc2 = pCoin->cbc;
     510                        //pCoin->cbc2 = pCoin->cbc;
    509511                        CbcMain0(*pCoin->cbc);
    510512                }
    511513#endif
    512514        }
    513         //pCoin->cbc->solver()->copyInIntegerInformation(pCoin->IsInt);
    514 
    515515        return SOLV_SUCCESS;
    516516}
     
    567567
    568568
    569 /****************************************************************/
    570 
    571 
    572 int CoinWriteMsgLog(char *FormatStr, ...)
    573 {
    574    va_list pVa;
    575    char strbuf[256];
    576 
    577    va_start(pVa,FormatStr);
    578    vsprintf(strbuf,FormatStr,pVa);
     569/************************************************************************/
     570/*  Callback Handling                                                   */
     571/************************************************************************/
     572
     573
     574int coinWriteMsgLog(char *FormatStr, ...)
     575{
     576        va_list pVa;
     577        char strbuf[256];
     578
     579        va_start(pVa,FormatStr);
     580        vsprintf(strbuf,FormatStr,pVa);
    579581        global_pCoin->MessageLogCallback(strbuf);
    580582        return SOLV_SUCCESS;
     
    582584
    583585
    584 int CoinIterLogCallback(int IterCount, double ObjectValue, int IsFeasible, double InfeasValue)
     586int coinIterLogCallback(int IterCount, double ObjectValue, int IsFeasible, double InfeasValue)
    585587{
    586588        if (!global_pCoin->SolveAsMIP) {
     
    588590                         ((IterCount % 100) == 0)) {
    589591                        if (!IsFeasible)
    590                                 CoinWriteMsgLog("Iteration: %5d  %16.8lg  %16.8lg",IterCount, ObjectValue, InfeasValue);
     592                                coinWriteMsgLog("Iteration: %5d  %16.8lg  %16.8lg",IterCount, ObjectValue, InfeasValue);
    591593                        else {
    592                                 CoinWriteMsgLog("Iteration: %5d  %16.8lg",IterCount, ObjectValue);
     594                                coinWriteMsgLog("Iteration: %5d  %16.8lg",IterCount, ObjectValue);
    593595                        }
    594596                }
     
    599601
    600602
    601 int CoinNodeLogCallback(int IterCount, int NodeCount, double BestBound, double BestObject, int IsMipImproved)
     603int coinNodeLogCallback(int IterCount, int NodeCount, double BestBound, double BestObject, int IsMipImproved)
    602604{
    603605        if ((NodeCount > 0) && (((NodeCount % 100) == 0) || (IsMipImproved))) {
    604                 CoinWriteMsgLog("Node: %5d  %s  %16.8lg  %16.8lg",
     606                coinWriteMsgLog("Node: %5d  %s  %16.8lg  %16.8lg",
    605607                                   NodeCount, (IsMipImproved) ? "*" : " ", BestBound, BestObject);
    606608        }
    607    global_pCoin->MipNodeCallback(IterCount, NodeCount, BestBound, BestObject, IsMipImproved);
     609        global_pCoin->MipNodeCallback(IterCount, NodeCount, BestBound, BestObject, IsMipImproved);
    608610        return SOLV_SUCCESS;
    609611}
     
    614616SOLVAPI int CoinSetMsgLogCallback(HPROB hProb, MSGLOGCALLBACK MsgLogCallback)
    615617{
    616    PCOIN pCoin = (PCOIN)hProb;
    617 
    618    pCoin->MessageLogCallback = MsgLogCallback;
     618        PCOIN pCoin = (PCOIN)hProb;
     619
     620        pCoin->MessageLogCallback = MsgLogCallback;
    619621        delete pCoin->msghandler;
    620622        pCoin->msghandler = new CBMessageHandler();
     
    631633SOLVAPI int CoinSetIterCallback(HPROB hProb, ITERCALLBACK IterCallback)
    632634{
    633    PCOIN pCoin = (PCOIN)hProb;
    634 
    635    pCoin->IterationCallback = IterCallback;
     635        PCOIN pCoin = (PCOIN)hProb;
     636
     637        pCoin->IterationCallback = IterCallback;
    636638        delete pCoin->iterhandler;
    637639        pCoin->iterhandler = new CBIterHandler(pCoin->clp);
     
    644646SOLVAPI int CoinSetMipNodeCallback(HPROB hProb, NODECALLBACK NodeCallback)
    645647{
    646    PCOIN pCoin = (PCOIN)hProb;
    647 
    648         //return SOLV_FAILED;  // BK 7/26/2006: using the NodeCallback crashes CBC!
    649 
    650    pCoin->MipNodeCallback = NodeCallback;
     648        PCOIN pCoin = (PCOIN)hProb;
     649
     650        pCoin->MipNodeCallback = NodeCallback;
    651651        delete pCoin->nodehandler;
    652652
     
    655655
    656656        pCoin->nodehandler->setCallback(NodeCallback);
    657         //if (pCoin->iterhandler) pCoin->iterhandler->setNodeCallback(NodeCallback);
    658657#ifdef NEW_STYLE_CBCMAIN
    659658        if (CoinGetIntOption(hProb, COIN_INT_MIPUSECBCMAIN)) {
    660                 if (pCoin->cbc2) pCoin->cbc2->passInEventHandler(pCoin->nodehandler);
     659                //if (pCoin->cbc2) pCoin->cbc2->passInEventHandler(pCoin->nodehandler);
     660                if (pCoin->cbc) pCoin->cbc->passInEventHandler(pCoin->nodehandler);
    661661                }
    662662        else
     
    670670
    671671
    672 /****************************************************************/
     672/************************************************************************/
     673/*  Option Setting                                                      */
     674/************************************************************************/
     675
    673676
    674677int coinSetClpOptions(HPROB hProb)
     
    822825        return 1;
    823826}
     827
     828
     829
     830/************************************************************************/
     831/*  Optimization                                                        */
     832/************************************************************************/
    824833
    825834
     
    865874
    866875
     876/************************************************************************/
     877/*  Solution status                                                     */
     878/************************************************************************/
     879
     880
    867881SOLVAPI int CoinGetSolutionStatus(HPROB hProb)
    868882{
     
    939953
    940954
    941 /****************************************************************/
     955
     956/************************************************************************/
     957/*  Solution retrieval                                                  */
     958/************************************************************************/
    942959
    943960
     
    10071024
    10081025
    1009 /****************************************************************/
     1026/************************************************************************/
     1027/*  File Handling                                                       */
     1028/************************************************************************/
    10101029
    10111030
     
    10651084
    10661085
    1067 /****************************************************************/
    1068 /****************************************************************/
    1069 
     1086
     1087/************************************************************************/
     1088/*  Option Table                                                        */
     1089/************************************************************************/
     1090
     1091#undef MAXINT
     1092#undef MAXREAL
    10701093
    10711094#define MAXINT          2100000000L
     
    12211244
    12221245
     1246/************************************************************************/
     1247/*  Option Handling                                                     */
     1248/************************************************************************/
     1249
    12231250
    12241251SOLVAPI int CoinGetOptionCount(HPROB hProb)
     
    12641291
    12651292
    1266 
    1267 
    1268 /****************************************************************/
    1269 
    1270 
    1271 
    1272 int LocateOptionID(int OptionID)
     1293int coinLocateOptionID(int OptionID)
    12731294{
    12741295        int i;
     
    12821303}
    12831304
     1305
    12841306SOLVAPI int CoinGetOptionChanged(HPROB hProb, int OptionID)
    12851307{
     
    12871309        int OptionNr;
    12881310
    1289         OptionNr = LocateOptionID(OptionID);
     1311        OptionNr = coinLocateOptionID(OptionID);
    12901312        if (OptionNr < 0) {
    12911313                return 0;
     
    13001322        int OptionNr;
    13011323
    1302         OptionNr = LocateOptionID(OptionID);
     1324        OptionNr = coinLocateOptionID(OptionID);
    13031325        if (OptionNr < 0) {
    13041326                return 0;
     
    13181340        int OptionNr;
    13191341
    1320         OptionNr = LocateOptionID(OptionID);
     1342        OptionNr = coinLocateOptionID(OptionID);
    13211343        if (OptionNr < 0) {
    13221344                return SOLV_FAILED;
    13231345        }
    13241346        if (OptionTable[OptionNr].OptionType != OPT_REAL) {
    1325                 CoinWriteMsgLog("%s[%d] = %d (was %d)",OptionTable[OptionNr].OptionName, OptionNr, IntValue, (int)OptionTable[OptionNr].CurrentValue);
     1347                coinWriteMsgLog("%s[%d] = %d (was %d)",OptionTable[OptionNr].OptionName, OptionNr, IntValue, (int)OptionTable[OptionNr].CurrentValue);
    13261348                OptionTable[OptionNr].CurrentValue = IntValue;
    13271349                OptionTable[OptionNr].changed = 1;
     
    13381360        int OptionNr;
    13391361
    1340         OptionNr = LocateOptionID(OptionID);
     1362        OptionNr = coinLocateOptionID(OptionID);
    13411363        if (OptionNr < 0) {
    13421364                return 0.0;
     
    13551377        int OptionNr;
    13561378
    1357         OptionNr = LocateOptionID(OptionID);
     1379        OptionNr = coinLocateOptionID(OptionID);
    13581380        if (OptionNr < 0) {
    13591381                return SOLV_FAILED;
    13601382        }
    13611383        if (OptionTable[OptionNr].OptionType == OPT_REAL) {
    1362                 CoinWriteMsgLog("%s[%d] = %lg (was %lg)",OptionTable[OptionNr].OptionName, OptionNr, RealValue, OptionTable[OptionNr].CurrentValue);
     1384                coinWriteMsgLog("%s[%d] = %lg (was %lg)",OptionTable[OptionNr].OptionName, OptionNr, RealValue, OptionTable[OptionNr].CurrentValue);
    13631385                OptionTable[OptionNr].CurrentValue = RealValue;
    13641386                OptionTable[OptionNr].changed = 1;
     
    13851407
    13861408
    1387 /****************************************************************/
     1409
     1410/************************************************************************/
     1411/*  DLL Handling                                                        */
     1412/************************************************************************/
    13881413
    13891414
  • trunk/CoinMP/src/CoinMP.h

    r88 r95  
    55/*  File         :  'coinmp.h'                                          */
    66/*                                                                      */
    7 /*  Author       :  Bjarni Kristjansson                                 */
     7/*  Version      :  1.1                                                 */
     8/*                                                                      */
     9/*  Author       :  Bjarni Kristjansson, Maximal Software               */
     10/*                                                                      */
     11/*  Copyright (c) 2002-2008                     Bjarni Kristjansson     */
    812/*                                                                      */
    913/************************************************************************/
    1014
    1115
    12 #ifndef COINMP_H
    13 #define COINMP_H
     16#ifndef _COINMP_H_
     17#define _COINMP_H_
    1418
    1519
     
    4751
    4852#ifdef __cplusplus
    49 
    50    extern "C"
    51       {
    52 
     53extern "C" {
    5354#endif
    5455
     
    144145SOLVAPI int    CoinGetRealOptionMinMax(HPROB hProb, int OptionNr, double *MinValue, double *MaxValue);
    145146
    146 SOLVAPI int CoinGetOptionChanged(HPROB hProb, int OptionID);
     147SOLVAPI int    CoinGetOptionChanged(HPROB hProb, int OptionID);
    147148
    148149SOLVAPI int    CoinGetIntOption(HPROB hProb, int OptionID);
     
    234235int    (SOLVFUNC *CoinGetRealOptionMinMax)(HPROB hProb, int OptionNr, double *MinValue, double *MaxValue);
    235236
    236 int        (SOLVAPI *CoinGetOptionChanged)(HPROB hProb, int OptionID);
     237int    (SOLVFUNC *CoinGetOptionChanged)(HPROB hProb, int OptionID);
    237238
    238239int    (SOLVFUNC *CoinGetIntOption)(HPROB hProb, int OptionID);
     
    248249
    249250#ifdef __cplusplus
    250 
    251  }
    252 
     251}
    253252#endif
    254253
     
    285284#define COIN_INT_MIPFATHOMDISC     20
    286285#define COIN_INT_MIPHOTSTART       21
    287 /*#define COIN_INT_MIPFORCEPRIOR     21*/
     286//#define COIN_INT_MIPFORCEPRIOR     21
    288287#define COIN_INT_MIPMINIMUMDROP    22
    289288#define COIN_INT_MIPMAXCUTPASS     23
Note: See TracChangeset for help on using the changeset viewer.