Changeset 366


Ignore:
Timestamp:
Nov 16, 2009 1:16:32 PM (10 years ago)
Author:
bjarni
Message:

Extract pOption/CoinOption.cpp out of pSolver/CoinSolver.cpp and update option calls in CoinCbc?

Location:
trunk/CoinMP
Files:
6 edited

Legend:

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

    r348 r366  
    213213                        </File>
    214214                        <File
     215                                RelativePath="..\..\..\src\CoinOption.c"
     216                                >
     217                        </File>
     218                        <File
    215219                                RelativePath="..\..\..\src\CoinProblem.c"
    216220                                >
     
    247251                        </File>
    248252                        <File
     253                                RelativePath="..\..\..\src\CoinOption.h"
     254                                >
     255                        </File>
     256                        <File
    249257                                RelativePath="..\..\..\src\CoinProblem.h"
    250258                                >
  • trunk/CoinMP/src/CoinCbc.cpp

    r360 r366  
    66#include "CoinResult.h"
    77#include "CoinSolver.h"
     8#include "CoinOption.h"
    89
    910#include <cfloat>
     
    338339
    339340
    340 int CbcSetMsgLogCallback(HCBC hCbc, MSGLOGCALLBACK MsgLogCallback)
    341 {
    342         PCBC pCbc = (PCBC)hCbc;
    343         int LogLevel;
     341int CbcSetMsgLogCallback(HCBC hCbc, int LogLevel, MSGLOGCALLBACK MsgLogCallback)
     342{
     343        PCBC pCbc = (PCBC)hCbc;
    344344
    345345        if (!MsgLogCallback) {
     
    350350        pCbc->msghandler = new CBMessageHandler();
    351351        pCbc->msghandler->setCallback(MsgLogCallback);
    352         LogLevel = CbcGetIntOption(COIN_INT_LOGLEVEL);
    353352        pCbc->msghandler->setLogLevel(LogLevel);
    354353        if (pCbc->clp) pCbc->clp->passInMessageHandler(pCbc->msghandler);
     
    392391
    393392
    394 int CbcSetAllCallbacks(HCBC hCbc, PSOLVER pSolver)
    395 {
    396         CbcSetMsgLogCallback(hCbc, pSolver->MsgLogCallback);
     393int CbcSetAllCallbacks(HCBC hCbc, PSOLVER pSolver, POPTION pOption)
     394{
     395        int LogLevel;
     396
     397        LogLevel = coinGetIntOption(pOption, COIN_INT_LOGLEVEL);
     398        CbcSetMsgLogCallback(hCbc, LogLevel, pSolver->MsgLogCallback);
    397399        CbcSetIterCallback(hCbc, pSolver->IterCallback);
    398400        CbcSetMipNodeCallback(hCbc, pSolver->MipNodeCallback);
     
    407409
    408410
    409 int CbcSetClpOptions(HCBC hCbc)
     411int CbcSetClpOptions(HCBC hCbc, POPTION pOption)
    410412{
    411413        PCBC pCbc = (PCBC)hCbc;
     
    414416
    415417        /* check if it has been changed, leave alone otherwise */
    416         if (CbcGetOptionChanged(COIN_INT_SCALING))                      pCbc->clp->scaling(CbcGetIntOption(COIN_INT_SCALING));
    417         if (CbcGetOptionChanged(COIN_INT_PERTURBATION))         pCbc->clp->setPerturbation(CbcGetIntOption(COIN_INT_PERTURBATION));
    418 
    419         if (CbcGetOptionChanged(COIN_REAL_MAXSECONDS))          pCbc->clp->setMaximumSeconds(CbcGetRealOption(COIN_REAL_MAXSECONDS));
    420         if (CbcGetOptionChanged(COIN_INT_MAXITER))                      pCbc->clp->setMaximumIterations(CbcGetIntOption(COIN_INT_MAXITER));
    421 
    422         if (CbcGetOptionChanged(COIN_REAL_PRIMALOBJLIM))        pCbc->clp->setPrimalObjectiveLimit(CbcGetRealOption(COIN_REAL_PRIMALOBJLIM));
    423         if (CbcGetOptionChanged(COIN_REAL_DUALOBJLIM))          pCbc->clp->setDualObjectiveLimit(CbcGetRealOption(COIN_REAL_DUALOBJLIM));
    424         if (CbcGetOptionChanged(COIN_REAL_PRIMALOBJTOL))        pCbc->clp->setPrimalTolerance(CbcGetRealOption(COIN_REAL_PRIMALOBJTOL));
    425         if (CbcGetOptionChanged(COIN_REAL_DUALOBJTOL))          pCbc->clp->setDualTolerance(CbcGetRealOption(COIN_REAL_DUALOBJTOL));
    426 
    427         if (CbcGetOptionChanged(COIN_INT_PRIMALPIVOTALG)) {
    428                 ClpPrimalColumnSteepest primalSteepest(CbcGetIntOption(COIN_INT_PRIMALPIVOTALG));
     418        if (coinGetOptionChanged(pOption, COIN_INT_SCALING))                    pCbc->clp->scaling(coinGetIntOption(pOption, COIN_INT_SCALING));
     419        if (coinGetOptionChanged(pOption, COIN_INT_PERTURBATION))               pCbc->clp->setPerturbation(coinGetIntOption(pOption, COIN_INT_PERTURBATION));
     420
     421        if (coinGetOptionChanged(pOption, COIN_REAL_MAXSECONDS))                pCbc->clp->setMaximumSeconds(coinGetRealOption(pOption, COIN_REAL_MAXSECONDS));
     422        if (coinGetOptionChanged(pOption, COIN_INT_MAXITER))                    pCbc->clp->setMaximumIterations(coinGetIntOption(pOption, COIN_INT_MAXITER));
     423
     424        if (coinGetOptionChanged(pOption, COIN_REAL_PRIMALOBJLIM))      pCbc->clp->setPrimalObjectiveLimit(coinGetRealOption(pOption, COIN_REAL_PRIMALOBJLIM));
     425        if (coinGetOptionChanged(pOption, COIN_REAL_DUALOBJLIM))                pCbc->clp->setDualObjectiveLimit(coinGetRealOption(pOption, COIN_REAL_DUALOBJLIM));
     426        if (coinGetOptionChanged(pOption, COIN_REAL_PRIMALOBJTOL))      pCbc->clp->setPrimalTolerance(coinGetRealOption(pOption, COIN_REAL_PRIMALOBJTOL));
     427        if (coinGetOptionChanged(pOption, COIN_REAL_DUALOBJTOL))                pCbc->clp->setDualTolerance(coinGetRealOption(pOption, COIN_REAL_DUALOBJTOL));
     428
     429        if (coinGetOptionChanged(pOption, COIN_INT_PRIMALPIVOTALG)) {
     430                ClpPrimalColumnSteepest primalSteepest(coinGetIntOption(pOption, COIN_INT_PRIMALPIVOTALG));
    429431                pCbc->clp->setPrimalColumnPivotAlgorithm(primalSteepest);
    430432        }
    431433
    432         if (CbcGetOptionChanged(COIN_INT_DUALPIVOTALG)) {
    433                 ClpDualRowSteepest dualSteepest(CbcGetIntOption(COIN_INT_DUALPIVOTALG));
     434        if (coinGetOptionChanged(pOption, COIN_INT_DUALPIVOTALG)) {
     435                ClpDualRowSteepest dualSteepest(coinGetIntOption(pOption, COIN_INT_DUALPIVOTALG));
    434436                pCbc->clp->setDualRowPivotAlgorithm(dualSteepest);
    435437        }
    436438
    437         if (CbcGetOptionChanged(COIN_INT_CRASHIND)) {
    438                 if (CbcGetIntOption(COIN_INT_CRASHIND)) {
    439                         pCbc->clp->crash(CbcGetRealOption(COIN_REAL_CRASHGAP),
    440                                                                 CbcGetIntOption(COIN_INT_CRASHPIVOT));
    441                 }
    442         }
    443 
    444         if (CbcGetOptionChanged(COIN_INT_SOLVEMETHOD)) {
    445                 switch (CbcGetIntOption(COIN_INT_SOLVEMETHOD)) {
     439        if (coinGetOptionChanged(pOption, COIN_INT_CRASHIND)) {
     440                if (coinGetIntOption(pOption, COIN_INT_CRASHIND)) {
     441                        pCbc->clp->crash(coinGetRealOption(pOption, COIN_REAL_CRASHGAP),
     442                                                                coinGetIntOption(pOption, COIN_INT_CRASHPIVOT));
     443                }
     444        }
     445
     446        if (coinGetOptionChanged(pOption, COIN_INT_SOLVEMETHOD)) {
     447                switch (coinGetIntOption(pOption, COIN_INT_SOLVEMETHOD)) {
    446448                        case 0: method = ClpSolve::useDual;                             break;
    447449                        case 1: method = ClpSolve::usePrimal;                   break;
     
    455457        }
    456458
    457         if (CbcGetOptionChanged(COIN_INT_PRESOLVETYPE)) {   
    458                 switch (CbcGetIntOption(COIN_INT_PRESOLVETYPE)) {
     459        if (coinGetOptionChanged(pOption, COIN_INT_PRESOLVETYPE)) {   
     460                switch (coinGetIntOption(pOption, COIN_INT_PRESOLVETYPE)) {
    459461                        case 0: presolve = ClpSolve::presolveOn;                 break;
    460462                        case 1: presolve = ClpSolve::presolveOff;                break;
     
    468470
    469471
    470 int CbcSetCbcOptions(HCBC hCbc)
     472int CbcSetCbcOptions(HCBC hCbc, POPTION pOption)
    471473{
    472474        PCBC pCbc = (PCBC)hCbc;
     
    475477                return 0;
    476478        }
    477         if (CbcGetOptionChanged(COIN_INT_MIPMAXNODES))          pCbc->cbc->setMaximumNodes(CbcGetIntOption(COIN_INT_MIPMAXNODES));
    478         if (CbcGetOptionChanged(COIN_INT_MIPMAXSOL))            pCbc->cbc->setMaximumSolutions(CbcGetIntOption(COIN_INT_MIPMAXSOL));
    479         if (CbcGetOptionChanged(COIN_REAL_MIPMAXSEC))           pCbc->cbc->setDblParam(CbcModel::CbcMaximumSeconds,CbcGetRealOption(COIN_REAL_MIPMAXSEC));
    480 
    481         if (CbcGetOptionChanged(COIN_INT_MIPFATHOMDISC))        pCbc->cbc->setIntParam(CbcModel::CbcFathomDiscipline,CbcGetIntOption(COIN_INT_MIPFATHOMDISC));
    482 
    483         // JPF commented: pCbc->cbc->setHotstartStrategy(CbcGetIntOption(COIN_INT_MIPHOTSTART));
    484         //              pCbc->cbc->setForcePriority(CbcGetIntOption(COIN_INT_MIPFORCEPRIOR));
    485 
    486         if (CbcGetOptionChanged(COIN_INT_MIPMINIMUMDROP))       pCbc->cbc->setMinimumDrop(CbcGetIntOption(COIN_INT_MIPMINIMUMDROP));
    487         if (CbcGetOptionChanged(COIN_INT_MIPMAXPASSROOT))       pCbc->cbc->setMaximumCutPassesAtRoot(CbcGetIntOption(COIN_INT_MIPMAXPASSROOT));
    488         if (CbcGetOptionChanged(COIN_INT_MIPMAXCUTPASS))        pCbc->cbc->setMaximumCutPasses(CbcGetIntOption(COIN_INT_MIPMAXCUTPASS));
    489         if (CbcGetOptionChanged(COIN_INT_MIPSTRONGBRANCH))      pCbc->cbc->setNumberStrong(CbcGetIntOption(COIN_INT_MIPSTRONGBRANCH));
    490         if (CbcGetOptionChanged(COIN_INT_MIPSCANGLOBCUTS))      pCbc->cbc->setHowOftenGlobalScan(CbcGetIntOption(COIN_INT_MIPSCANGLOBCUTS));
    491 
    492         if (CbcGetOptionChanged(COIN_REAL_MIPINTTOL))           pCbc->cbc->setIntegerTolerance(CbcGetRealOption(COIN_REAL_MIPINTTOL));
    493         if (CbcGetOptionChanged(COIN_REAL_MIPINFWEIGHT))        pCbc->cbc->setInfeasibilityWeight(CbcGetRealOption(COIN_REAL_MIPINFWEIGHT));
    494         if (CbcGetOptionChanged(COIN_REAL_MIPCUTOFF))           pCbc->cbc->setDblParam(CbcModel::CbcCutoffIncrement,CbcGetRealOption(COIN_REAL_MIPCUTOFF));
    495         if (CbcGetOptionChanged(COIN_REAL_MIPABSGAP))           pCbc->cbc->setAllowableGap(CbcGetRealOption(COIN_REAL_MIPABSGAP));
    496         if (CbcGetOptionChanged(COIN_REAL_MIPFRACGAP))          pCbc->cbc->setAllowableFractionGap(CbcGetRealOption(COIN_REAL_MIPFRACGAP));
     479        if (coinGetOptionChanged(pOption, COIN_INT_MIPMAXNODES))                pCbc->cbc->setMaximumNodes(coinGetIntOption(pOption, COIN_INT_MIPMAXNODES));
     480        if (coinGetOptionChanged(pOption, COIN_INT_MIPMAXSOL))          pCbc->cbc->setMaximumSolutions(coinGetIntOption(pOption, COIN_INT_MIPMAXSOL));
     481        if (coinGetOptionChanged(pOption, COIN_REAL_MIPMAXSEC))         pCbc->cbc->setDblParam(CbcModel::CbcMaximumSeconds,coinGetRealOption(pOption, COIN_REAL_MIPMAXSEC));
     482
     483        if (coinGetOptionChanged(pOption, COIN_INT_MIPFATHOMDISC))      pCbc->cbc->setIntParam(CbcModel::CbcFathomDiscipline,coinGetIntOption(pOption, COIN_INT_MIPFATHOMDISC));
     484
     485        // JPF commented: pCbc->cbc->setHotstartStrategy(coinGetIntOption(pOption, COIN_INT_MIPHOTSTART));
     486        //              pCbc->cbc->setForcePriority(coinGetIntOption(pOption, COIN_INT_MIPFORCEPRIOR));
     487
     488        if (coinGetOptionChanged(pOption, COIN_INT_MIPMINIMUMDROP))     pCbc->cbc->setMinimumDrop(coinGetIntOption(pOption, COIN_INT_MIPMINIMUMDROP));
     489        if (coinGetOptionChanged(pOption, COIN_INT_MIPMAXPASSROOT))     pCbc->cbc->setMaximumCutPassesAtRoot(coinGetIntOption(pOption, COIN_INT_MIPMAXPASSROOT));
     490        if (coinGetOptionChanged(pOption, COIN_INT_MIPMAXCUTPASS))      pCbc->cbc->setMaximumCutPasses(coinGetIntOption(pOption, COIN_INT_MIPMAXCUTPASS));
     491        if (coinGetOptionChanged(pOption, COIN_INT_MIPSTRONGBRANCH))    pCbc->cbc->setNumberStrong(coinGetIntOption(pOption, COIN_INT_MIPSTRONGBRANCH));
     492        if (coinGetOptionChanged(pOption, COIN_INT_MIPSCANGLOBCUTS))    pCbc->cbc->setHowOftenGlobalScan(coinGetIntOption(pOption, COIN_INT_MIPSCANGLOBCUTS));
     493
     494        if (coinGetOptionChanged(pOption, COIN_REAL_MIPINTTOL))         pCbc->cbc->setIntegerTolerance(coinGetRealOption(pOption, COIN_REAL_MIPINTTOL));
     495        if (coinGetOptionChanged(pOption, COIN_REAL_MIPINFWEIGHT))      pCbc->cbc->setInfeasibilityWeight(coinGetRealOption(pOption, COIN_REAL_MIPINFWEIGHT));
     496        if (coinGetOptionChanged(pOption, COIN_REAL_MIPCUTOFF))         pCbc->cbc->setDblParam(CbcModel::CbcCutoffIncrement,coinGetRealOption(pOption, COIN_REAL_MIPCUTOFF));
     497        if (coinGetOptionChanged(pOption, COIN_REAL_MIPABSGAP))         pCbc->cbc->setAllowableGap(coinGetRealOption(pOption, COIN_REAL_MIPABSGAP));
     498        if (coinGetOptionChanged(pOption, COIN_REAL_MIPFRACGAP))                pCbc->cbc->setAllowableFractionGap(coinGetRealOption(pOption, COIN_REAL_MIPFRACGAP));
    497499        return 1;
    498500}
    499501
    500502
    501 int CbcSetCglOptions(HCBC hCbc)
     503int CbcSetCglOptions(HCBC hCbc, POPTION pOption)
    502504{
    503505        PCBC pCbc = (PCBC)hCbc;
    504506
    505507        /* see CbcModel.hpp has commments on calling cuts */
    506         if (CbcGetIntOption(COIN_INT_MIPCUT_PROBING)) {
     508        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_PROBING)) {
    507509                pCbc->probing = new CglProbing();
    508                 if (CbcGetOptionChanged(COIN_INT_MIPPROBE_MODE))        pCbc->probing->setMode(CbcGetIntOption(COIN_INT_MIPPROBE_MODE));
    509                 if (CbcGetOptionChanged(COIN_INT_MIPPROBE_USEOBJ))      pCbc->probing->setUsingObjective(CbcGetIntOption(COIN_INT_MIPPROBE_USEOBJ) ? true : false);
    510                 if (CbcGetOptionChanged(COIN_INT_MIPPROBE_MAXPASS))     pCbc->probing->setMaxPass(CbcGetIntOption(COIN_INT_MIPPROBE_MAXPASS));
    511                 if (CbcGetOptionChanged(COIN_INT_MIPPROBE_MAXPROBE))    pCbc->probing->setMaxProbe(CbcGetIntOption(COIN_INT_MIPPROBE_MAXPROBE));
    512                 if (CbcGetOptionChanged(COIN_INT_MIPPROBE_MAXLOOK))     pCbc->probing->setMaxLook(CbcGetIntOption(COIN_INT_MIPPROBE_MAXLOOK));
    513                 if (CbcGetOptionChanged(COIN_INT_MIPPROBE_ROWCUTS))     pCbc->probing->setRowCuts(CbcGetIntOption(COIN_INT_MIPPROBE_ROWCUTS));
    514                 pCbc->cbc->addCutGenerator(pCbc->probing,CbcGetIntOption(COIN_INT_MIPPROBE_FREQ),"Probing");
    515         }
    516 
    517         if (CbcGetIntOption(COIN_INT_MIPCUT_GOMORY)) {
     510                if (coinGetOptionChanged(pOption, COIN_INT_MIPPROBE_MODE))      pCbc->probing->setMode(coinGetIntOption(pOption, COIN_INT_MIPPROBE_MODE));
     511                if (coinGetOptionChanged(pOption, COIN_INT_MIPPROBE_USEOBJ))    pCbc->probing->setUsingObjective(coinGetIntOption(pOption, COIN_INT_MIPPROBE_USEOBJ) ? true : false);
     512                if (coinGetOptionChanged(pOption, COIN_INT_MIPPROBE_MAXPASS))   pCbc->probing->setMaxPass(coinGetIntOption(pOption, COIN_INT_MIPPROBE_MAXPASS));
     513                if (coinGetOptionChanged(pOption, COIN_INT_MIPPROBE_MAXPROBE))  pCbc->probing->setMaxProbe(coinGetIntOption(pOption, COIN_INT_MIPPROBE_MAXPROBE));
     514                if (coinGetOptionChanged(pOption, COIN_INT_MIPPROBE_MAXLOOK))   pCbc->probing->setMaxLook(coinGetIntOption(pOption, COIN_INT_MIPPROBE_MAXLOOK));
     515                if (coinGetOptionChanged(pOption, COIN_INT_MIPPROBE_ROWCUTS))   pCbc->probing->setRowCuts(coinGetIntOption(pOption, COIN_INT_MIPPROBE_ROWCUTS));
     516                pCbc->cbc->addCutGenerator(pCbc->probing,coinGetIntOption(pOption, COIN_INT_MIPPROBE_FREQ),"Probing");
     517        }
     518
     519        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_GOMORY)) {
    518520                pCbc->gomory = new CglGomory();
    519                 if (CbcGetOptionChanged(COIN_INT_MIPGOMORY_LIMIT))      pCbc->gomory->setLimit(CbcGetIntOption(COIN_INT_MIPGOMORY_LIMIT));
    520                 if (CbcGetOptionChanged(COIN_REAL_MIPGOMORY_AWAY))      pCbc->gomory->setAway(CbcGetRealOption(COIN_REAL_MIPGOMORY_AWAY));
    521                 pCbc->cbc->addCutGenerator(pCbc->gomory,CbcGetIntOption(COIN_INT_MIPGOMORY_FREQ),"Gomory");
    522         }
    523 
    524         if (CbcGetIntOption(COIN_INT_MIPCUT_KNAPSACK)) {
     521                if (coinGetOptionChanged(pOption, COIN_INT_MIPGOMORY_LIMIT))    pCbc->gomory->setLimit(coinGetIntOption(pOption, COIN_INT_MIPGOMORY_LIMIT));
     522                if (coinGetOptionChanged(pOption, COIN_REAL_MIPGOMORY_AWAY))    pCbc->gomory->setAway(coinGetRealOption(pOption, COIN_REAL_MIPGOMORY_AWAY));
     523                pCbc->cbc->addCutGenerator(pCbc->gomory,coinGetIntOption(pOption, COIN_INT_MIPGOMORY_FREQ),"Gomory");
     524        }
     525
     526        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_KNAPSACK)) {
    525527                pCbc->knapsack = new CglKnapsackCover();
    526                 if (CbcGetOptionChanged(COIN_INT_MIPKNAPSACK_MAXIN))    pCbc->knapsack->setMaxInKnapsack(CbcGetIntOption(COIN_INT_MIPKNAPSACK_MAXIN));
    527                 pCbc->cbc->addCutGenerator(pCbc->knapsack,CbcGetIntOption(COIN_INT_MIPKNAPSACK_FREQ),"Knapsack");
    528         }
    529 
    530         if (CbcGetIntOption(COIN_INT_MIPCUT_ODDHOLE)) {
     528                if (coinGetOptionChanged(pOption, COIN_INT_MIPKNAPSACK_MAXIN))  pCbc->knapsack->setMaxInKnapsack(coinGetIntOption(pOption, COIN_INT_MIPKNAPSACK_MAXIN));
     529                pCbc->cbc->addCutGenerator(pCbc->knapsack,coinGetIntOption(pOption, COIN_INT_MIPKNAPSACK_FREQ),"Knapsack");
     530        }
     531
     532        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_ODDHOLE)) {
    531533                pCbc->oddhole= new CglOddHole();
    532                 if (CbcGetOptionChanged(COIN_REAL_MIPODDHOLE_MINVIOL))  pCbc->oddhole->setMinimumViolation(CbcGetRealOption(COIN_REAL_MIPODDHOLE_MINVIOL));
    533                 if (CbcGetOptionChanged(COIN_REAL_MIPODDHOLE_MINVIOLPER))       pCbc->oddhole->setMinimumViolationPer(CbcGetRealOption(COIN_REAL_MIPODDHOLE_MINVIOLPER));
    534                 if (CbcGetOptionChanged(COIN_INT_MIPODDHOLE_MAXENTRIES))        pCbc->oddhole->setMaximumEntries(CbcGetIntOption(COIN_INT_MIPODDHOLE_MAXENTRIES));
    535                 pCbc->cbc->addCutGenerator(pCbc->oddhole,CbcGetIntOption(COIN_INT_MIPODDHOLE_FREQ),"OddHole");
    536         }
    537 
    538         if (CbcGetIntOption(COIN_INT_MIPCUT_CLIQUE)) {
    539                 pCbc->clique= new CglClique(CbcGetIntOption(COIN_INT_MIPCLIQUE_PACKING) ? true : false);
    540                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_STAR))               pCbc->clique->setDoStarClique(CbcGetIntOption(COIN_INT_MIPCLIQUE_STAR) ? true : false);
    541                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_STARMETHOD)) pCbc->clique->setStarCliqueNextNodeMethod((CglClique::scl_next_node_method)CbcGetIntOption(COIN_INT_MIPCLIQUE_STARMETHOD));
    542                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_STARMAXLEN)) pCbc->clique->setStarCliqueCandidateLengthThreshold(CbcGetIntOption(COIN_INT_MIPCLIQUE_STARMAXLEN));
    543                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_STARREPORT)) pCbc->clique->setStarCliqueReport(CbcGetIntOption(COIN_INT_MIPCLIQUE_STARREPORT) ? true : false);
    544                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_ROW))                pCbc->clique->setDoRowClique(CbcGetIntOption(COIN_INT_MIPCLIQUE_ROW) ? true : false);
    545                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_ROWMAXLEN))  pCbc->clique->setRowCliqueCandidateLengthThreshold(CbcGetIntOption(COIN_INT_MIPCLIQUE_ROWMAXLEN));
    546                 if (CbcGetOptionChanged(COIN_INT_MIPCLIQUE_ROWREPORT))  pCbc->clique->setRowCliqueReport(CbcGetIntOption(COIN_INT_MIPCLIQUE_ROWREPORT) ? true : false);
    547                 if (CbcGetOptionChanged(COIN_REAL_MIPCLIQUE_MINVIOL))   pCbc->clique->setMinViolation(CbcGetRealOption(COIN_REAL_MIPCLIQUE_MINVIOL));
    548                 pCbc->cbc->addCutGenerator(pCbc->clique,CbcGetIntOption(COIN_INT_MIPCLIQUE_FREQ),"Clique");
    549         }
    550 
    551         if (CbcGetIntOption(COIN_INT_MIPCUT_LIFTPROJECT)) {
     534                if (coinGetOptionChanged(pOption, COIN_REAL_MIPODDHOLE_MINVIOL))        pCbc->oddhole->setMinimumViolation(coinGetRealOption(pOption, COIN_REAL_MIPODDHOLE_MINVIOL));
     535                if (coinGetOptionChanged(pOption, COIN_REAL_MIPODDHOLE_MINVIOLPER))     pCbc->oddhole->setMinimumViolationPer(coinGetRealOption(pOption, COIN_REAL_MIPODDHOLE_MINVIOLPER));
     536                if (coinGetOptionChanged(pOption, COIN_INT_MIPODDHOLE_MAXENTRIES))      pCbc->oddhole->setMaximumEntries(coinGetIntOption(pOption, COIN_INT_MIPODDHOLE_MAXENTRIES));
     537                pCbc->cbc->addCutGenerator(pCbc->oddhole,coinGetIntOption(pOption, COIN_INT_MIPODDHOLE_FREQ),"OddHole");
     538        }
     539
     540        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_CLIQUE)) {
     541                pCbc->clique= new CglClique(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_PACKING) ? true : false);
     542                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_STAR))             pCbc->clique->setDoStarClique(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_STAR) ? true : false);
     543                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_STARMETHOD))       pCbc->clique->setStarCliqueNextNodeMethod((CglClique::scl_next_node_method)coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_STARMETHOD));
     544                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_STARMAXLEN))       pCbc->clique->setStarCliqueCandidateLengthThreshold(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_STARMAXLEN));
     545                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_STARREPORT))       pCbc->clique->setStarCliqueReport(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_STARREPORT) ? true : false);
     546                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_ROW))              pCbc->clique->setDoRowClique(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_ROW) ? true : false);
     547                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_ROWMAXLEN))        pCbc->clique->setRowCliqueCandidateLengthThreshold(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_ROWMAXLEN));
     548                if (coinGetOptionChanged(pOption, COIN_INT_MIPCLIQUE_ROWREPORT))        pCbc->clique->setRowCliqueReport(coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_ROWREPORT) ? true : false);
     549                if (coinGetOptionChanged(pOption, COIN_REAL_MIPCLIQUE_MINVIOL)) pCbc->clique->setMinViolation(coinGetRealOption(pOption, COIN_REAL_MIPCLIQUE_MINVIOL));
     550                pCbc->cbc->addCutGenerator(pCbc->clique,coinGetIntOption(pOption, COIN_INT_MIPCLIQUE_FREQ),"Clique");
     551        }
     552
     553        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_LIFTPROJECT)) {
    552554                pCbc->liftpro = new CglLiftAndProject();
    553                 if (CbcGetOptionChanged(COIN_INT_MIPLIFTPRO_BETAONE))   pCbc->liftpro->setBeta(CbcGetIntOption(COIN_INT_MIPLIFTPRO_BETAONE) ? 1 : -1);
    554                 pCbc->cbc->addCutGenerator(pCbc->liftpro,CbcGetIntOption(COIN_INT_MIPLIFTPRO_FREQ),"LiftProject");
    555         }
    556 
    557         if (CbcGetIntOption(COIN_INT_MIPCUT_SIMPROUND)) {
     555                if (coinGetOptionChanged(pOption, COIN_INT_MIPLIFTPRO_BETAONE)) pCbc->liftpro->setBeta(coinGetIntOption(pOption, COIN_INT_MIPLIFTPRO_BETAONE) ? 1 : -1);
     556                pCbc->cbc->addCutGenerator(pCbc->liftpro,coinGetIntOption(pOption, COIN_INT_MIPLIFTPRO_FREQ),"LiftProject");
     557        }
     558
     559        if (coinGetIntOption(pOption, COIN_INT_MIPCUT_SIMPROUND)) {
    558560                pCbc->rounding = new CglSimpleRounding();
    559                 pCbc->cbc->addCutGenerator(pCbc->rounding,CbcGetIntOption(COIN_INT_MIPSIMPROUND_FREQ),"Rounding");
     561                pCbc->cbc->addCutGenerator(pCbc->rounding,coinGetIntOption(pOption, COIN_INT_MIPSIMPROUND_FREQ),"Rounding");
    560562        }
    561563        return 1;
     
    747749extern int CbcOrClpRead_mode;
    748750
    749 int CbcSolveProblem(HCBC hCbc, PPROBLEM pProblem, int Method)
     751int CbcSolveProblem(HCBC hCbc, PPROBLEM pProblem, POPTION pOption, int Method)
    750752{
    751753        PCBC pCbc = (PCBC)hCbc;
    752754
    753755        if (!pProblem->SolveAsMIP) {
    754                 CbcSetClpOptions(hCbc);
    755                 if (CbcGetOptionChanged(COIN_INT_PRESOLVETYPE))                 
     756                CbcSetClpOptions(hCbc, pOption);
     757                if (coinGetOptionChanged(pOption, COIN_INT_PRESOLVETYPE))                       
    756758                        pCbc->clp->initialSolve(*pCbc->clp_presolve);
    757759                else {
     
    761763        else {
    762764#ifdef NEW_STYLE_CBCMAIN
    763                 if (CbcGetIntOption(COIN_INT_MIPUSECBCMAIN)) {
     765                if (coinGetIntOption(pOption, COIN_INT_MIPUSECBCMAIN)) {
    764766                        CbcMain0(*pCbc->cbc);
    765                         CbcSetClpOptions(hCbc);
    766                         CbcSetCbcOptions(hCbc);
     767                        CbcSetClpOptions(hCbc, pOption);
     768                        CbcSetCbcOptions(hCbc, pOption);
    767769                        //CbcSetCglOptions(hProb);  BK: CbcMain1 will call the Cgl's automatically
    768770                        CbcOrClpRead_mode = 1;  // BK: Fix bug in CbcMain1, CbcOrClpRead_mode not initialized  (CpcSolver.cpp, stable 2.2)
     
    774776#endif
    775777                {
    776                         CbcSetClpOptions(hCbc);
    777                         CbcSetCbcOptions(hCbc);
    778                         CbcSetCglOptions(hCbc);
     778                        CbcSetClpOptions(hCbc, pOption);
     779                        CbcSetCbcOptions(hCbc, pOption);
     780                        CbcSetCglOptions(hCbc, pOption);
    779781
    780782                        pCbc->cbc->initialSolve();
     
    854856
    855857
    856 int CbcOptimizeProblem(PPROBLEM pProblem, PRESULT pResult, PSOLVER pSolver, int Method)
     858int CbcOptimizeProblem(PPROBLEM pProblem, PRESULT pResult, PSOLVER pSolver, POPTION pOption, int Method)
    857859{               
    858860        HCBC hCbc;
     
    861863        hCbc = CbcCreateSolverObject();
    862864        result = CbcLoadAllSolverObjects(hCbc, pProblem);
    863         result = CbcSetAllCallbacks(hCbc, pSolver);
    864         result = CbcSolveProblem(hCbc, pProblem, Method);
     865        result = CbcSetAllCallbacks(hCbc, pSolver, pOption);
     866        result = CbcSolveProblem(hCbc, pProblem, pOption, Method);
    865867        result = CbcRetrieveSolutionResults(hCbc, pProblem, pResult);
    866868        CbcClearSolverObject(hCbc);
  • trunk/CoinMP/src/CoinCbc.h

    r349 r366  
    4747#define CBC_CALL_FAILED    -1
    4848
    49 int CbcOptimizeProblem(PPROBLEM pProblem, PRESULT pResult, PSOLVER pSolver, int Method);
     49int CbcOptimizeProblem(PPROBLEM pProblem, PRESULT pResult, PSOLVER pSolver, POPTION pOption, int Method);
    5050
    5151int CbcReadMpsFile(PPROBLEM pProblem, const char *ReadFilename);
  • trunk/CoinMP/src/CoinMP.cpp

    r365 r366  
    2424#include "CoinResult.h"
    2525#include "CoinSolver.h"
     26#include "CoinOption.h"
    2627
    2728#include "CoinCbc.h"
     
    132133                                PRESULT   pResult;
    133134                                PSOLVER   pSolver;
     135                                POPTION   pOption;
    134136
    135137                                } COININFO, *PCOIN;
     
    155157        pCoin->pResult = coinCreateResultObject();
    156158        pCoin->pSolver = coinCreateSolverObject();
     159        pCoin->pOption = coinCreateOptionObject();
    157160
    158161        coinSetProblemName(pCoin->pProblem, ProblemName);
    159         coinCopyOptionTable(pCoin->pSolver, CbcGetOptionTable(), CbcGetOptionCount());
     162        coinCopyOptionTable(pCoin->pOption, CbcGetOptionTable(), CbcGetOptionCount());
    160163
    161164        return (HPROB)pCoin;
     
    171174                coinClearResultObject(pCoin->pResult);
    172175                coinClearSolverObject(pCoin->pSolver);
     176                coinClearOptionObject(pCoin->pOption);
    173177        }
    174178        free(pCoin);
     
    558562        PCOIN pCoin = (PCOIN)hProb;
    559563
    560         return CbcOptimizeProblem(pCoin->pProblem, pCoin->pResult, pCoin->pSolver, Method);
     564        return CbcOptimizeProblem(pCoin->pProblem, pCoin->pResult, pCoin->pSolver, pCoin->pOption, Method);
    561565}
    562566
     
    769773        PCOIN pCoin = (PCOIN)hProb;
    770774
    771         return coinGetOptionCount(pCoin->pSolver);
     775        return coinGetOptionCount(pCoin->pOption);
    772776}
    773777
     
    776780        PCOIN pCoin = (PCOIN)hProb;
    777781
    778         return coinLocateOptionID(pCoin->pSolver, OptionID);
     782        return coinLocateOptionID(pCoin->pOption, OptionID);
    779783}
    780784
     
    784788        PCOIN pCoin = (PCOIN)hProb;
    785789
    786         return coinLocateOptionName(pCoin->pSolver, OptionName);
     790        return coinLocateOptionName(pCoin->pOption, OptionName);
    787791}
    788792
     
    793797        PCOIN pCoin = (PCOIN)hProb;
    794798
    795         return coinGetOptionID(pCoin->pSolver, OptionNr);
     799        return coinGetOptionID(pCoin->pOption, OptionNr);
    796800}
    797801
     
    802806        int optionID;
    803807
    804         optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
     808        optionID = coinGetOptionID(pCoin->pOption, OptionNr);
    805809        if (OptionID)   *OptionID = optionID;
    806         if (OptionType) *OptionType = coinGetOptionType(pCoin->pSolver, optionID);
    807         if (GroupType)  *GroupType = coinGetOptionGroup(pCoin->pSolver, optionID);
     810        if (OptionType) *OptionType = coinGetOptionType(pCoin->pOption, optionID);
     811        if (GroupType)  *GroupType = coinGetOptionGroup(pCoin->pOption, optionID);
    808812        return SOLV_CALL_SUCCESS;
    809813}
     
    815819        int optionID;
    816820
    817         optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
    818         if (MinValue)   *MinValue = coinGetIntOptionMinValue(pCoin->pSolver, optionID);
    819         if (MaxValue)   *MaxValue = coinGetIntOptionMaxValue(pCoin->pSolver, optionID);
     821        optionID = coinGetOptionID(pCoin->pOption, OptionNr);
     822        if (MinValue)   *MinValue = coinGetIntOptionMinValue(pCoin->pOption, optionID);
     823        if (MaxValue)   *MaxValue = coinGetIntOptionMaxValue(pCoin->pOption, optionID);
    820824        return SOLV_CALL_SUCCESS;
    821825}
     
    827831        int optionID;
    828832
    829         optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
    830         if (MinValue)   *MinValue = coinGetRealOptionMinValue(pCoin->pSolver, optionID);
    831         if (MaxValue)   *MaxValue = coinGetRealOptionMaxValue(pCoin->pSolver, optionID);
     833        optionID = coinGetOptionID(pCoin->pOption, OptionNr);
     834        if (MinValue)   *MinValue = coinGetRealOptionMinValue(pCoin->pOption, optionID);
     835        if (MaxValue)   *MaxValue = coinGetRealOptionMaxValue(pCoin->pOption, optionID);
    832836        return SOLV_CALL_SUCCESS;
    833837}
     
    840844        int optionID;
    841845
    842         optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
    843         if (OptionName) coinGetOptionNameBuf(pCoin->pSolver, optionID, OptionName, buflen);
    844         if (ShortName) coinGetOptionShortNameBuf(pCoin->pSolver, optionID, ShortName, buflen);
     846        optionID = coinGetOptionID(pCoin->pOption, OptionNr);
     847        if (OptionName) coinGetOptionNameBuf(pCoin->pOption, optionID, OptionName, buflen);
     848        if (ShortName) coinGetOptionShortNameBuf(pCoin->pOption, optionID, ShortName, buflen);
    845849        return SOLV_CALL_SUCCESS;
    846850}
     
    854858        PCOIN pCoin = (PCOIN)hProb;
    855859
    856         return coinGetOptionGroup(pCoin->pSolver, OptionID);
     860        return coinGetOptionGroup(pCoin->pOption, OptionID);
    857861}
    858862
     
    862866        PCOIN pCoin = (PCOIN)hProb;
    863867
    864         return coinGetOptionType(pCoin->pSolver, OptionID);
     868        return coinGetOptionType(pCoin->pOption, OptionID);
    865869}
    866870
     
    872876        PCOIN pCoin = (PCOIN)hProb;
    873877
    874         return coinGetIntOptionDefaultValue(pCoin->pSolver, OptionID);
     878        return coinGetIntOptionDefaultValue(pCoin->pOption, OptionID);
    875879}
    876880
     
    880884        PCOIN pCoin = (PCOIN)hProb;
    881885
    882         return coinGetIntOptionMinValue(pCoin->pSolver, OptionID);
     886        return coinGetIntOptionMinValue(pCoin->pOption, OptionID);
    883887}
    884888
     
    888892        PCOIN pCoin = (PCOIN)hProb;
    889893
    890         return coinGetIntOptionMaxValue(pCoin->pSolver, OptionID);
     894        return coinGetIntOptionMaxValue(pCoin->pOption, OptionID);
    891895}
    892896
     
    897901        PCOIN pCoin = (PCOIN)hProb;
    898902
    899         return coinGetRealOptionDefaultValue(pCoin->pSolver, OptionID);
     903        return coinGetRealOptionDefaultValue(pCoin->pOption, OptionID);
    900904}
    901905
     
    905909        PCOIN pCoin = (PCOIN)hProb;
    906910
    907         return coinGetRealOptionMinValue(pCoin->pSolver, OptionID);
     911        return coinGetRealOptionMinValue(pCoin->pOption, OptionID);
    908912}
    909913
     
    913917        PCOIN pCoin = (PCOIN)hProb;
    914918
    915         return coinGetRealOptionMaxValue(pCoin->pSolver, OptionID);
     919        return coinGetRealOptionMaxValue(pCoin->pOption, OptionID);
    916920}
    917921
     
    923927        PCOIN pCoin = (PCOIN)hProb;
    924928
    925         return coinGetOptionName(pCoin->pSolver, OptionID);
     929        return coinGetOptionName(pCoin->pOption, OptionID);
    926930}
    927931
     
    931935        PCOIN pCoin = (PCOIN)hProb;
    932936
    933         return coinGetOptionNameBuf(pCoin->pSolver, OptionID, OptionName, buflen);
     937        return coinGetOptionNameBuf(pCoin->pOption, OptionID, OptionName, buflen);
    934938}
    935939
     
    939943        PCOIN pCoin = (PCOIN)hProb;
    940944
    941         return coinGetOptionShortName(pCoin->pSolver, OptionID);
     945        return coinGetOptionShortName(pCoin->pOption, OptionID);
    942946}
    943947
     
    947951        PCOIN pCoin = (PCOIN)hProb;
    948952
    949         return coinGetOptionShortNameBuf(pCoin->pSolver, OptionID, ShortName, buflen);
     953        return coinGetOptionShortNameBuf(pCoin->pOption, OptionID, ShortName, buflen);
    950954}
    951955
     
    957961        PCOIN pCoin = (PCOIN)hProb;
    958962
    959         return coinGetOptionChanged(pCoin->pSolver, OptionID);
     963        return coinGetOptionChanged(pCoin->pOption, OptionID);
    960964}
    961965
     
    965969        PCOIN pCoin = (PCOIN)hProb;
    966970
    967         return coinGetIntOption(pCoin->pSolver, OptionID);
     971        return coinGetIntOption(pCoin->pOption, OptionID);
    968972}
    969973       
     
    974978        PCOIN pCoin = (PCOIN)hProb;
    975979
    976         return coinSetIntOption(pCoin->pSolver, OptionID, IntValue);
     980        return coinSetIntOption(pCoin->pOption, OptionID, IntValue);
    977981}
    978982
     
    983987        PCOIN pCoin = (PCOIN)hProb;
    984988
    985         return coinGetRealOption(pCoin->pSolver, OptionID);
     989        return coinGetRealOption(pCoin->pOption, OptionID);
    986990}
    987991
     
    992996        PCOIN pCoin = (PCOIN)hProb;
    993997
    994         return coinSetRealOption(pCoin->pSolver, OptionID, RealValue);
     998        return coinSetRealOption(pCoin->pOption, OptionID, RealValue);
    995999}
    9961000
  • trunk/CoinMP/src/CoinSolver.c

    r347 r366  
    1717        strcpy(pSolver->LogFilename, "");
    1818
    19         pSolver->OptionCount = 0;
    20         pSolver->OptionCopy = 0;
    21         pSolver->OptionTable = NULL;
    22 
    2319        pSolver->MsgLogCallback = NULL;
    2420        pSolver->IterCallback = NULL;
     
    3228{
    3329        if (!pSolver) {
    34                 if (pSolver->OptionCopy && pSolver->OptionTable) {
    35                         free(pSolver->OptionTable);
    36                 }
    3730                return;
    3831        }
     
    5447}
    5548
    56 
    57 
    58 void coinCopyOptionTable(PSOLVER pSolver, OPTIONTABLE OptionTable, int OptionCount)
    59 {
    60         if (!pSolver) {
    61                 return;
    62         }
    63         if (pSolver->OptionCount > 0) {
    64                 pSolver->OptionCount = OptionCount;
    65                 pSolver->OptionTable = (PSOLVOPT)malloc(OptionCount * sizeof(SOLVOPTINFO));
    66                 memcpy(pSolver->OptionTable, OptionTable, OptionCount * sizeof(SOLVOPTINFO));
    67                 pSolver->OptionCopy = 1;
    68         }
    69 }
    70 
    71 
    72 void coinSetOptionTable(PSOLVER pSolver, OPTIONTABLE OptionTable, int OptionCount)
    73 {
    74         if (!pSolver) {
    75                 return;
    76         }
    77         pSolver->OptionTable = OptionTable;
    78         pSolver->OptionCount = OptionCount;
    79 }
    80 
    81 
    82 int coinGetOptionCount(PSOLVER pSolver)
    83 {
    84         if (pSolver == NULL) {
    85                 return 0;
    86         }
    87         return pSolver->OptionCount;
    88 }
    89 
    90 
    91 int coinGetOptionID(PSOLVER pSolver, int OptionNr)
    92 {
    93         if ((OptionNr < 0) || (OptionNr >= pSolver->OptionCount)) {
    94                 return -1;
    95         }
    96         return pSolver->OptionTable[OptionNr].OptionID;
    97 }
    98 
    99 
    100 int coinLocateOptionID(PSOLVER pSolver, int OptionID)
    101 {
    102         int i;
    103 
    104         for (i = 0; i < pSolver->OptionCount; i++) {
    105                 if (OptionID == pSolver->OptionTable[i].OptionID) {
    106                         return i;
    107                 }
    108         }
    109         return -1;
    110 }
    111 
    112 
    113 int coinGetOptionType(PSOLVER pSolver, int OptionID)
    114 {
    115         int OptionNr;
    116 
    117         OptionNr = coinLocateOptionID(pSolver, OptionID);
    118         if (OptionNr == -1) {
    119                 return OPT_NONE;
    120         }
    121         return pSolver->OptionTable[OptionNr].OptionType;
    122 }
    123 
    124 
    125 int coinGetOptionGroup(PSOLVER pSolver, int OptionID)
    126 {
    127         int OptionNr;
    128 
    129         OptionNr = coinLocateOptionID(pSolver, OptionID);
    130         if (OptionNr == -1) {
    131                 return GRP_NONE;
    132         }
    133         return pSolver->OptionTable[OptionNr].GroupType;
    134 }
    135 
    136 
    137 #ifdef _WIN32
    138  #define STRING_COMPARE_NOCASE(s1, s2)  strcmpi(s1, s2)
    139 #else
    140  #define STRING_COMPARE_NOCASE(s1, s2)  strcasecmp(s1, s2)
    141 #endif
    142 
    143 int coinLocateOptionName(PSOLVER pSolver, char* OptionName)
    144 {
    145         int i;
    146 
    147         for (i = 0; i < pSolver->OptionCount; i++) {
    148                 if (STRING_COMPARE_NOCASE(OptionName, pSolver->OptionTable[i].OptionName) != 0) {
    149                         return pSolver->OptionTable[i].OptionID;
    150                 }
    151                 if (STRING_COMPARE_NOCASE(OptionName, pSolver->OptionTable[i].ShortName) != 0) {
    152                         return pSolver->OptionTable[i].OptionID;
    153                 }
    154         }
    155         return -1;
    156 }
    157 
    158 
    159 const char* coinGetOptionName(PSOLVER pSolver, int OptionID)
    160 {
    161         int OptionNr;
    162 
    163         OptionNr = coinLocateOptionID(pSolver, OptionID);
    164         if (OptionNr == -1) {
    165                 return "";
    166         }
    167         return pSolver->OptionTable[OptionNr].OptionName;
    168 }
    169 
    170 
    171 int coinGetOptionNameBuf(PSOLVER pSolver, int OptionID, char* OptionName, int buflen)
    172 {
    173         int OptionNr;
    174 
    175         OptionNr = coinLocateOptionID(pSolver, OptionID);
    176         if (OptionNr == -1) {
    177                 if (OptionName) {
    178                         strcpy(OptionName, "");
    179                 }
    180                 return -1;
    181         }
    182         if (OptionName) {
    183                 strncpy(OptionName, pSolver->OptionTable[OptionNr].OptionName, buflen-1);
    184                 OptionName[buflen-1] = '\0';
    185         }
    186         return 0;
    187 }
    188 
    189 const char* coinGetOptionShortName(PSOLVER pSolver, int OptionID)
    190 {
    191         int OptionNr;
    192 
    193         OptionNr = coinLocateOptionID(pSolver, OptionID);
    194         if (OptionNr == -1) {
    195                 return "";
    196         }
    197         return pSolver->OptionTable[OptionNr].ShortName;
    198 }
    199 
    200 
    201 int coinGetOptionShortNameBuf(PSOLVER pSolver, int OptionID, char* ShortName, int buflen)
    202 {
    203         int OptionNr;
    204 
    205         OptionNr = coinLocateOptionID(pSolver, OptionID);
    206         if (OptionNr == -1) {
    207                 if (ShortName) {
    208                         strcpy(ShortName, "");
    209                 }
    210                 return -1;
    211         }
    212         if (ShortName) {
    213                 strncpy(ShortName, pSolver->OptionTable[OptionNr].ShortName, buflen-1);
    214                 ShortName[buflen-1] = '\0';
    215         }
    216         return 0;
    217 }
    218 
    219 
    220 int coinGetIntOptionDefaultValue(PSOLVER pSolver, int OptionID)
    221 {
    222         int OptionNr;
    223 
    224         OptionNr = coinLocateOptionID(pSolver, OptionID);
    225         if (OptionNr == -1) {
    226                 return 0;
    227         }
    228         return (int)pSolver->OptionTable[OptionNr].DefaultValue;
    229 }
    230 
    231 
    232 
    233 int coinGetIntOptionMinValue(PSOLVER pSolver, int OptionID)
    234 {
    235         int OptionNr;
    236 
    237         OptionNr = coinLocateOptionID(pSolver, OptionID);
    238         if (OptionNr == -1) {
    239                 return 0;
    240         }
    241         return (int)pSolver->OptionTable[OptionNr].MinValue;
    242 }
    243 
    244 
    245 
    246 int coinGetIntOptionMaxValue(PSOLVER pSolver, int OptionID)
    247 {
    248         int OptionNr;
    249 
    250         OptionNr = coinLocateOptionID(pSolver, OptionID);
    251         if (OptionNr == -1) {
    252                 return 0;
    253         }
    254         return (int)pSolver->OptionTable[OptionNr].MaxValue;
    255 }
    256 
    257 
    258 
    259 
    260 double coinGetRealOptionDefaultValue(PSOLVER pSolver, int OptionID)
    261 {
    262         int OptionNr;
    263 
    264         OptionNr = coinLocateOptionID(pSolver, OptionID);
    265         if (OptionNr == -1) {
    266                 return 0.0;
    267         }
    268         return pSolver->OptionTable[OptionNr].DefaultValue;
    269 }
    270 
    271 
    272 
    273 double coinGetRealOptionMinValue(PSOLVER pSolver, int OptionID)
    274 {
    275         int OptionNr;
    276 
    277         OptionNr = coinLocateOptionID(pSolver, OptionID);
    278         if (OptionNr == -1) {
    279                 return 0.0;
    280         }
    281         return pSolver->OptionTable[OptionNr].MinValue;
    282 }
    283 
    284 
    285 
    286 double coinGetRealOptionMaxValue(PSOLVER pSolver, int OptionID)
    287 {
    288         int OptionNr;
    289 
    290         OptionNr = coinLocateOptionID(pSolver, OptionID);
    291         if (OptionNr == -1) {
    292                 return 0.0;
    293         }
    294         return pSolver->OptionTable[OptionNr].MaxValue;
    295 }
    296 
    297 int coinGetOptionChanged(PSOLVER pSolver, int OptionID)
    298 {
    299         int OptionNr;
    300 
    301         OptionNr = coinLocateOptionID(pSolver, OptionID);
    302         if (OptionNr == -1) {
    303                 return 0;
    304         }
    305         return pSolver->OptionTable[OptionNr].changed;
    306 }
    307 
    308 
    309 int coinGetIntOption(PSOLVER pSolver, int OptionID)
    310 {
    311         int OptionNr;
    312 
    313         OptionNr = coinLocateOptionID(pSolver, OptionID);
    314         if (OptionNr == -1) {
    315                 return 0;
    316         }
    317         return (int)pSolver->OptionTable[OptionNr].CurrentValue;
    318 }
    319 
    320 int coinSetIntOption(PSOLVER pSolver, int OptionID, int IntValue)
    321 {
    322         int OptionNr;
    323 
    324         OptionNr = coinLocateOptionID(pSolver, OptionID);
    325         if (OptionNr == -1) {
    326                 return -1;
    327         }
    328         pSolver->OptionTable[OptionNr].CurrentValue = IntValue;
    329         pSolver->OptionTable[OptionNr].changed = 1;
    330         return 0;
    331 }
    332 
    333 
    334 double coinGetRealOption(PSOLVER pSolver, int OptionID)
    335 {
    336         int OptionNr;
    337 
    338         OptionNr = coinLocateOptionID(pSolver, OptionID);
    339         if (OptionNr == -1) {
    340                 return 0.0;
    341         }
    342         return pSolver->OptionTable[OptionNr].CurrentValue;
    343 }
    344 
    345 
    346 int coinSetRealOption(PSOLVER pSolver, int OptionID, double RealValue)
    347 {
    348         int OptionNr;
    349 
    350         OptionNr = coinLocateOptionID(pSolver, OptionID);
    351         if (OptionNr == -1) {
    352                 return -1;
    353         }
    354         pSolver->OptionTable[OptionNr].CurrentValue = RealValue;
    355         pSolver->OptionTable[OptionNr].changed = 1;
    356         return 0;
    357 }
    358 
  • trunk/CoinMP/src/CoinSolver.h

    r347 r366  
    1212#define SOLVCALL
    1313#endif
    14 
    15 
    16 #undef MAXINT
    17 #undef MAXREAL
    18 
    19 #define MAXINT          2100000000L
    20 #define MAXREAL         COIN_DBL_MAX
    21 
    22 #define ROUND(x)       (((x)>0)?((long)((x)+0.5)):((long)((x)-0.5)))
    23 
    24 
    25 #define OPT_NONE                        0
    26 #define OPT_ONOFF                       1
    27 #define OPT_LIST                        2
    28 #define OPT_INT                         3
    29 #define OPT_REAL                        4
    30 #define OPT_STRING                      5
    31 
    32 #define GRP_NONE                        0
    33 #define GRP_OTHER                       0
    34 
    35 #define GRP_SIMPLEX                     1
    36 #define GRP_PREPROC                     2
    37 #define GRP_LOGFILE                     3
    38 #define GRP_LIMITS                      4
    39 #define GRP_MIPSTRAT            5
    40 #define GRP_MIPCUTS                     6
    41 #define GRP_MIPTOL                      7
    42 #define GRP_BARRIER                     8
    43 #define GRP_NETWORK                     9
    44 
    45 
    46 typedef int    OPTINT;
    47 typedef double OPTVAL;
    48 
    49 typedef struct {
    50                         char   OptionName[32];
    51                         char   ShortName[32];
    52                         int    GroupType;
    53                         OPTVAL DefaultValue;
    54                         OPTVAL CurrentValue;
    55                         OPTVAL MinValue;
    56                         OPTVAL MaxValue;
    57                         int             OptionType;
    58                         int    changed;
    59                         int    OptionID;
    60         } SOLVOPTINFO, *PSOLVOPT;
    61 
    62 
    63 typedef PSOLVOPT OPTIONTABLE;
    6414
    6515
     
    8030typedef struct {
    8131                                char LogFilename[260];
    82 
    83                                 int OptionCount;
    84                                 int OptionCopy;
    85                                 OPTIONTABLE OptionTable;
    8632
    8733                                MSGLOGCALLBACK  MsgLogCallback;
     
    10450const char* coinGetLogFilename(PSOLVER pSolver);
    10551
    106 void    coinSetOptionTable(PSOLVER pSolver, OPTIONTABLE OptionTable, int OptionCount);
    107 void    coinCopyOptionTable(PSOLVER pSolver, OPTIONTABLE OptionTable, int OptionCount);
    10852
    109 int     coinGetOptionCount(PSOLVER pSolver);
    110 int     coinGetOptionID(PSOLVER pSolver, int OptionNr);
    111 int     coinLocateOptionID(PSOLVER pSolver, int OptionID);
    112 
    113 int     coinGetOptionType(PSOLVER pSolver, int OptionID);
    114 int     coinGetOptionGroup(PSOLVER pSolver, int OptionID);
    115 
    116 int     coinLocateOptionName(PSOLVER pSolver, char* OptionName);
    117 const char*   coinGetOptionName(PSOLVER pSolver, int OptionID);
    118 int     coinGetOptionNameBuf(PSOLVER pSolver, int OptionID, char* OptionName, int buflen);
    119 const char*   coinGetOptionShortName(PSOLVER pSolver, int OptionNr);
    120 int     coinGetOptionShortNameBuf(PSOLVER pSolver, int OptionNr, char* ShortName, int buflen);
    121 
    122 int     coinGetIntOptionDefaultValue(PSOLVER pSolver, int OptionID);
    123 int     coinGetIntOptionMinValue(PSOLVER pSolver, int OptionID);
    124 int     coinGetIntOptionMaxValue(PSOLVER pSolver, int OptionID);
    125 
    126 double  coinGetRealOptionDefaultValue(PSOLVER pSolver, int OptionID);
    127 double  coinGetRealOptionMinValue(PSOLVER pSolver, int OptionID);
    128 double  coinGetRealOptionMaxValue(PSOLVER pSolver, int OptionID);
    129 
    130 int     coinGetOptionChanged(PSOLVER pSolver, int OptionID);
    131 
    132 int     coinGetIntOption(PSOLVER pSolver, int OptionID);
    133 int     coinSetIntOption(PSOLVER pSolver, int OptionID, int IntValue);
    134 
    135 double  coinGetRealOption(PSOLVER pSolver, int OptionID);
    136 int     coinSetRealOption(PSOLVER pSolver, int OptionID, double RealValue);
    13753#ifdef __cplusplus
    13854}
Note: See TracChangeset for help on using the changeset viewer.