Changeset 169


Ignore:
Timestamp:
Oct 2, 2005 3:42:43 PM (16 years ago)
Author:
forrest
Message:

for solve

Location:
trunk/Test
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Test/CbcOrClpParam.cpp

    r17 r169  
    710710      model.setNumberStrong(value);
    711711      break;
     712    case NUMBERBEFORE:
     713      oldValue=model.numberBeforeTrust();
     714      model.setNumberBeforeTrust(value);
     715      break;
    712716    default:
    713717      oldValue=0; // to avoid compiler message
     
    735739  case STRONGBRANCHING:
    736740    value=model.numberStrong();
     741    break;
     742  case NUMBERBEFORE:
     743    value=model.numberBeforeTrust();
    737744    break;
    738745  default:
     
    10411048                  "native",CHOLESKY,false);
    10421049  parameters[numberParameters-1].append("dense");
    1043 #ifdef FOREIGN_BARRIER
     1050  //#ifdef FOREIGN_BARRIER
    10441051#ifdef WSSMP_BARRIER
    10451052  parameters[numberParameters-1].append("fudge!Long");
    10461053  parameters[numberParameters-1].append("wssmp");
     1054#define REAL_BARRIER
    10471055#else
    10481056  parameters[numberParameters-1].append("fudge!Long_dummy");
     
    10511059#ifdef UFL_BARRIER
    10521060  parameters[numberParameters-1].append("Uni!versityOfFlorida");
     1061#define REAL_BARRIER
    10531062#else
    10541063  parameters[numberParameters-1].append("Uni!versityOfFlorida_dummy");
     
    10561065#ifdef TAUCS_BARRIER
    10571066  parameters[numberParameters-1].append("Taucs");
     1067#define REAL_BARRIER
    10581068#else
    10591069  parameters[numberParameters-1].append("Taucs_dummy");
    10601070#endif
    1061 #endif
     1071  //#endif
    10621072#ifdef COIN_USE_CBC
    10631073  parameters[numberParameters++]=
     
    10871097  parameters[numberParameters-1].append("so!low_halim");
    10881098  parameters[numberParameters-1].append("ha!lim_solow(JJF mods)");
     1099  parameters[numberParameters-1].append("4");
     1100  parameters[numberParameters-1].append("5");
    10891101  parameters[numberParameters-1].setLonghelp
    10901102    (
     
    11571169     );
    11581170  parameters[numberParameters++]=
     1171    CbcOrClpParam("dualize","Solves dual reformulation",
     1172                  0,1,DUALIZE,false);
     1173  parameters[numberParameters-1].setLonghelp
     1174    (
     1175     "Don't even think about it."
     1176     );
     1177  parameters[numberParameters++]=
    11591178    CbcOrClpParam("dualP!ivot","Dual pivot choice algorithm",
    11601179                  "auto!matic",DUALPIVOT);
     
    11901209 bit if a dual run seems to be having a hard time"
    11911210     );
     1211#ifdef COIN_USE_CLP
     1212  parameters[numberParameters++]=
     1213    CbcOrClpParam("either!Simplex","Do dual or primal simplex algorithm",
     1214                  EITHERSIMPLEX);
     1215  parameters[numberParameters-1].setLonghelp
     1216    (
     1217     "This command solves the current model using the dual or primal algorithm,\
     1218 based on a dubious analysis of model."
     1219     );
     1220#endif
    11921221  parameters[numberParameters++]=
    11931222    CbcOrClpParam("end","Stops clp execution",
     
    12781307  parameters[numberParameters++]=
    12791308    CbcOrClpParam("idiot!Crash","Whether to try idiot crash",
    1280                   -1,200,IDIOT);
     1309                  -1,999999,IDIOT);
    12811310  parameters[numberParameters-1].setLonghelp
    12821311    (
     
    14481477  parameters[numberParameters++]=
    14491478    CbcOrClpParam("netlib","Solve entire netlib test set",
     1479                  NETLIB_EITHER);
     1480  parameters[numberParameters-1].setLonghelp
     1481    (
     1482     "This exercises the unit test for clp and then solves the netlib test set using dual or primal.\
     1483The user can set options before e.g. clp -presolve off -netlib"
     1484     );
     1485#ifdef REAL_BARRIER
     1486  parameters[numberParameters++]=
     1487    CbcOrClpParam("netlibB!arrier","Solve entire netlib test set with barrier",
     1488                  NETLIB_BARRIER);
     1489  parameters[numberParameters-1].setLonghelp
     1490    (
     1491     "This exercises the unit test for clp and then solves the netlib test set using barrier.\
     1492The user can set options before e.g. clp -kkt on -netlib"
     1493     );
     1494#endif
     1495  parameters[numberParameters++]=
     1496    CbcOrClpParam("netlibD!ual","Solve entire netlib test set (dual)",
    14501497                  NETLIB_DUAL);
    14511498  parameters[numberParameters-1].setLonghelp
     
    14541501The user can set options before e.g. clp -presolve off -netlib"
    14551502     );
    1456 #ifdef REAL_BARRIER
    1457   parameters[numberParameters++]=
    1458     CbcOrClpParam("netlibB!arrier","Solve entire netlib test set with barrier",
    1459                   NETLIB_BARRIER);
    1460   parameters[numberParameters-1].setLonghelp
    1461     (
    1462      "This exercises the unit test for clp and then solves the netlib test set using barrier.\
    1463 The user can set options before e.g. clp -presolve off -netlib"
    1464      );
    1465 #endif
    14661503  parameters[numberParameters++]=
    14671504    CbcOrClpParam("netlibP!rimal","Solve entire netlib test set (primal)",
     
    14711508     "This exercises the unit test for clp and then solves the netlib test set using primal.\
    14721509The user can set options before e.g. clp -presolve off -netlibp"
     1510     );
     1511  parameters[numberParameters++]=
     1512    CbcOrClpParam("netlibT!une","Solve entire netlib test set with 'best' algorithm",
     1513                  NETLIB_TUNE);
     1514  parameters[numberParameters-1].setLonghelp
     1515    (
     1516     "This exercises the unit test for clp and then solves the netlib test set using whatever \
     1517works best.  I know this is cheating but it also stresses the code better by doing a \
     1518mixture of stuff.  The best algorithm was chosen on a Linux ThinkPad using native cholesky \
     1519with University of Florida ordering."
    14731520     );
    14741521  parameters[numberParameters++]=
     
    14911538     );
    14921539  parameters[numberParameters-1].setDoubleValue(1.0);
    1493 #endif
    1494 #ifdef COIN_USE_CBC
    1495     parameters[numberParameters++]=
    1496       CbcOrClpParam("oddhole!Cuts","Whether to use Oddhole cuts",
    1497               "off",ODDHOLECUTS);
    1498     parameters[numberParameters-1].append("on");
    1499     parameters[numberParameters-1].append("root");
    1500   parameters[numberParameters-1].setLonghelp
    1501     (
    1502      "TODO"
    1503      );
    15041540#endif
    15051541  parameters[numberParameters++]=
     
    15181554  parameters[numberParameters++]=
    15191555    CbcOrClpParam("passP!resolve","How many passes in presolve",
    1520                   0,100,PRESOLVEPASS,false);
     1556                  -200,100,PRESOLVEPASS,false);
    15211557  parameters[numberParameters-1].setLonghelp
    15221558    (
     
    15721608 initial solve of any problem this is worth doing unless you know that it will have no effect."
    15731609     );
     1610#ifdef COIN_USE_CBC
     1611  parameters[numberParameters++]=
     1612    CbcOrClpParam("preprocess","Whether to use integer preprocessing",
     1613                  "on",PREPROCESS);
     1614  parameters[numberParameters-1].append("off");
     1615  parameters[numberParameters-1].setLonghelp
     1616    (
     1617     "TODO"
     1618     );
     1619#endif
    15741620#ifdef COIN_USE_CLP
    15751621  parameters[numberParameters++]=
     
    16521698    CbcOrClpParam("reallyS!cale","Scales model in place",
    16531699                  REALLY_SCALE,false);
     1700#endif
     1701#ifdef COIN_USE_CBC
     1702    parameters[numberParameters++]=
     1703      CbcOrClpParam("reduce!AndSplitCuts","Whether to use Reduce-and-Split cuts",
     1704              "off",REDSPLITCUTS);
     1705    parameters[numberParameters-1].append("on");
     1706    parameters[numberParameters-1].append("root");
     1707  parameters[numberParameters-1].setLonghelp
     1708    (
     1709     "TODO"
     1710     );
     1711#endif
     1712#ifdef COIN_USE_CLP
    16541713  parameters[numberParameters++]=
    16551714    CbcOrClpParam("restore!Model","Restore model from binary file",
     
    17641823  parameters[numberParameters-1].append("off");
    17651824  parameters[numberParameters++]=
    1766     CbcOrClpParam("special!Options","Dubious options for Simplex - see Clpsimplex.hpp",
     1825    CbcOrClpParam("special!Options","Dubious options for Simplex - see ClpSimplex.hpp",
    17671826                  0,INT_MAX,SPECIALOPTIONS,false);
    17681827  parameters[numberParameters++]=
     
    17761835  Cplex calls it 'sifting'.  -1 is automatic choice, 0 is off, n is number of passes"
    17771836     );
     1837  parameters[numberParameters++]=
     1838    CbcOrClpParam("stat!istics","Print some statistics",
     1839                  STATISTICS);
     1840  parameters[numberParameters-1].setLonghelp
     1841    (
     1842     "This command prints crude statistics for the current model.\
     1843 If log level >1 then more is printed.\
     1844 These are for presolved model if presolve on (and unscaled)."
     1845     );
    17781846#endif
    17791847  CbcOrClpParam("stdin","From stdin",
     
    17941862     "TODO"
    17951863     );
     1864#endif
     1865#ifdef COIN_USE_CLP
     1866  parameters[numberParameters++]=
     1867    CbcOrClpParam("subs!titution","How long a column to substitute for in presolve",
     1868                  0,10000,SUBSTITUTION,false);
     1869  parameters[numberParameters-1].setLonghelp
     1870    (
     1871     "Normally Presolve gets rid of 'free' variables when there are no more than 3 \
     1872 variables in column.  If you increase this the number of rows may decrease but number of \
     1873 elements may increase."
     1874     );
     1875#endif
     1876#ifdef COIN_USE_CBC
    17961877  parameters[numberParameters++]=
    17971878    CbcOrClpParam("tighten!Factor","Tighten bounds using this times largest \
     
    18131894#ifdef COIN_USE_CBC
    18141895  parameters[numberParameters++]=
     1896    CbcOrClpParam("trust!PseudoCosts","Number of branches before we trust pseudocosts",
     1897                  0,999999,NUMBERBEFORE);
     1898  parameters[numberParameters-1].setLonghelp
     1899    (
     1900     "TODO"
     1901     );
     1902#endif
     1903#ifdef COIN_USE_CBC
     1904  parameters[numberParameters++]=
    18151905    CbcOrClpParam("two!MirCuts","Whether to use Two phase Mixed Integer Rounding cuts",
    18161906                  "off",TWOMIRCUTS);
  • trunk/Test/CoinSolve.cpp

    r41 r169  
    1515#include "CoinHelperFunctions.hpp"
    1616// Same version as CBC
    17 #define CBCVERSION "0.70"
     17#define CBCVERSION "0.98"
    1818
    1919#include "CoinMpsIO.hpp"
     
    5252#include "OsiColCut.hpp"
    5353
     54#include "CglPreProcess.hpp"
    5455#include "CglCutGenerator.hpp"
    5556#include "CglGomory.hpp"
    5657#include "CglProbing.hpp"
    5758#include "CglKnapsackCover.hpp"
    58 #include "CglOddHole.hpp"
     59#include "CglRedSplit.hpp"
    5960#include "CglClique.hpp"
    6061#include "CglFlowCover.hpp"
     
    6667#include "CbcCompareActual.hpp"
    6768#include  "CbcOrClpParam.hpp"
    68 
    69 #ifdef COIN_USE_CLP
     69#include  "CbcCutGenerator.hpp"
     70
    7071#include "OsiClpSolverInterface.hpp"
    71 #endif
    72 #ifdef COIN_USE_DYLP
    73 #include "OsiDylpSolverInterface.hpp"
    74 #endif
    7572
    7673static double totalTime=0.0;
     
    103100int main (int argc, const char *argv[])
    104101{
    105   // next {} is just to make sure all memory should be freed - for debug
    106102  /* Note
    107103     This is meant as a stand-alone executable to do as much of coin as possible.
     
    110106  {
    111107    double time1 = CoinCpuTime(),time2;
     108    CoinSighandler_t saveSignal=SIG_DFL;
     109    // register signal handler
     110    saveSignal = signal(SIGINT,signal_handler);
    112111    // Set up all non-standard stuff
    113 #ifdef COIN_USE_CLP
    114112    OsiClpSolverInterface solver1;
    115113    CbcModel model(solver1);
     
    117115    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    118116    ClpSimplex * lpSolver = clpSolver->getModelPtr();
    119 #endif
     117    clpSolver->messageHandler()->setLogLevel(0) ;
     118    model.messageHandler()->setLogLevel(1);
    120119   
    121120   
     
    130129    int doCrash=0;
    131130    int doSprint=-1;
     131    int doScaling=1;
    132132    // set reasonable defaults
    133133    int preSolve=5;
     134    int preProcess=1;
    134135    bool preSolveFile=false;
    135136// Set up likely cut generators and defaults
     
    137138    CglGomory gomoryGen;
    138139    // try larger limit
    139     gomoryGen.setLimit(3000);
     140    gomoryGen.setLimit(300);
    140141    // set default action (0=off,1=on,2=root)
    141142    int gomoryAction=1;
     
    144145    probingGen.setUsingObjective(true);
    145146    probingGen.setMaxPass(3);
    146     probingGen.setMaxProbe(100);
    147     probingGen.setMaxLook(50);
     147    probingGen.setMaxPassRoot(3);
     148    // Number of unsatisfied variables to look at
     149    probingGen.setMaxProbe(10);
     150    probingGen.setMaxProbeRoot(50);
     151    // How far to follow the consequences
     152    probingGen.setMaxLook(10);
     153    probingGen.setMaxLookRoot(50);
     154    // Only look at rows with fewer than this number of elements
     155    probingGen.setMaxElements(200);
    148156    probingGen.setRowCuts(3);
    149157    // set default action (0=off,1=on,2=root)
     
    154162    int knapsackAction=1;
    155163
    156     CglOddHole oddholeGen;
    157     oddholeGen.setMinimumViolation(0.005);
    158     oddholeGen.setMinimumViolationPer(0.0002);
    159     oddholeGen.setMaximumEntries(100);
     164    CglRedSplit redsplitGen;
     165    redsplitGen.setLimit(100);
    160166    // set default action (0=off,1=on,2=root)
    161     int oddholeAction=1;
     167    int redsplitAction=1;
    162168
    163169    CglClique cliqueGen;
     
    209215    int slog = whichParam(SOLVERLOGLEVEL,numberParameters,parameters);
    210216    int log = whichParam(LOGLEVEL,numberParameters,parameters);
    211     parameters[slog].setIntValue(lpSolver->logLevel());
     217    parameters[slog].setIntValue(0);
     218    parameters[log].setIntValue(1);
    212219    parameters[whichParam(MAXFACTOR,numberParameters,parameters)].setIntValue(lpSolver->factorizationFrequency());
    213220    parameters[whichParam(MAXITERATION,numberParameters,parameters)].setIntValue(lpSolver->maximumIterations());
     
    226233    int numberGoodCommands=0;
    227234    bool goodModel=false;
     235    // Set false if user does anything advanced
     236    bool defaultSettings=true;
    228237
    229238    // Hidden stuff for barrier
     
    233242    int doKKT=0;
    234243    int crossover=2; // do crossover unless quadratic
     244    // For names
     245    int lengthName = 0;
     246    std::vector<std::string> rowNames;
     247    std::vector<std::string> columnNames;
    235248   
    236249    std::string field;
     
    294307        int valid;
    295308        numberGoodCommands++;
    296 #ifdef COIN_USE_CLP
    297309        if (type==BAB&&goodModel) {
    298310          // check if any integers
     
    300312            type=DUALSIMPLEX;
    301313        }
    302 #endif
    303314        if (type==GENERALQUERY) {
    304315          std::cout<<"In argument list keywords have leading - "
     
    390401                djFix=value;
    391402                preSolve=5;
     403                defaultSettings=false; // user knows what she is doing
    392404                break;
    393405              case GAPRATIO:
     
    396408              case TIGHTENFACTOR:
    397409                tightenFactor=value;
     410                defaultSettings=false; // user knows what she is doing
    398411                break;
    399412              default:
     
    507520              lpSolver->scaling(action);
    508521              solver->setHintParam(OsiDoScale,action!=0,OsiHintTry);
     522              doScaling = 1-action;
    509523              break;
    510524            case AUTOSCALE:
     
    526540              allowImportErrors = action;
    527541              break;
     542              //case ALGORITHM:
     543              //algorithm  = action;
     544              //defaultSettings=false; // user knows what she is doing
     545              //abort();
     546              //break;
    528547            case KEEPNAMES:
    529548              keepImportNames = 1-action;
     
    564583              break;
    565584            case GOMORYCUTS:
     585              defaultSettings=false; // user knows what she is doing
    566586              gomoryAction = action;
    567587              break;
    568588            case PROBINGCUTS:
     589              defaultSettings=false; // user knows what she is doing
    569590              probingAction = action;
    570591              break;
    571592            case KNAPSACKCUTS:
     593              defaultSettings=false; // user knows what she is doing
    572594              knapsackAction = action;
    573595              break;
    574             case ODDHOLECUTS:
    575               oddholeAction = action;
     596            case REDSPLITCUTS:
     597              defaultSettings=false; // user knows what she is doing
     598              redsplitAction = action;
    576599              break;
    577600            case CLIQUECUTS:
     601              defaultSettings=false; // user knows what she is doing
    578602              cliqueAction = action;
    579603              break;
    580604            case FLOWCUTS:
     605              defaultSettings=false; // user knows what she is doing
    581606              flowAction = action;
    582607              break;
    583608            case MIXEDCUTS:
     609              defaultSettings=false; // user knows what she is doing
    584610              mixedAction = action;
    585611              break;
    586612            case TWOMIRCUTS:
     613              defaultSettings=false; // user knows what she is doing
    587614              twomirAction = action;
    588615              break;
    589616            case ROUNDING:
     617              defaultSettings=false; // user knows what she is doing
    590618              useRounding = action;
    591619              break;
     
    623651                delete [] dsort;
    624652              }
     653              break;
     654            case PREPROCESS:
     655              preProcess = action;
    625656              break;
    626657            default:
     
    783814*/
    784815          case BAB: // branchAndBound
    785           { if (goodModel)
    786             { CbcCompareDefault compare; // Definition of node choice
    787               model.setNodeComparison(compare);
    788               model.messageHandler()->setLogLevel(parameters[log].intValue());
    789                 int depthCriterion= parameters[whichParam(CUTDEPTH,
    790                                                           numberParameters,
    791                                                           parameters)].intValue();
    792                 // add cut generators if wanted
    793                 if (probingAction==1)
    794                   model.addCutGenerator(&probingGen,-1,"Probing",
    795                                         true,false,false,-100,depthCriterion);
    796                 else if (probingAction==2)
    797                   model.addCutGenerator(&probingGen,-99,"Probing");
    798                 if (gomoryAction==1)
    799                   model.addCutGenerator(&gomoryGen,-1,"Gomory",
    800                                         true,false,false,-100,depthCriterion);
    801                 else if (gomoryAction==2)
    802                   model.addCutGenerator(&gomoryGen,-99,"Gomory");
    803                 if (knapsackAction==1)
    804                   model.addCutGenerator(&knapsackGen,-1,"Knapsack",
    805                                         true,false,false,-100,depthCriterion);
    806                 else if (knapsackAction==2)
    807                   model.addCutGenerator(&knapsackGen,-99,"Knapsack");
    808                 if (oddholeAction==1)
    809                   model.addCutGenerator(&oddholeGen,-1,"OddHole",
    810                                         true,false,false,-100,depthCriterion);
    811                 else if (oddholeAction==2)
    812                   model.addCutGenerator(&oddholeGen,-99,"OddHole");
    813                 if (cliqueAction==1)
    814                   model.addCutGenerator(&cliqueGen,-1,"Clique",
    815                                         true,false,false,-100,depthCriterion);
    816                 else if (cliqueAction==2)
    817                   model.addCutGenerator(&cliqueGen,-99,"Clique");
    818                 if (mixedAction==1)
    819                   model.addCutGenerator(&mixedGen,-1,"MixedintegerRounding",
    820                                         true,false,false,-100,depthCriterion);
    821                 else if (mixedAction==2)
    822                   model.addCutGenerator(&mixedGen,-99,"MixedintegerRounding");
    823                 if (flowAction==1)
    824                   model.addCutGenerator(&flowGen,-1,"FlowCover",
    825                                         true,false,false,-100,depthCriterion);
    826                 else if (flowAction==2)
    827                   model.addCutGenerator(&flowGen,-99,"FlowCover");
    828                 if (twomirAction==1)
    829                   model.addCutGenerator(&twomirGen,-1,"TwoMirCuts",
    830                                         true,false,false,-100,depthCriterion);
    831                 else if (twomirAction==2)
    832                   model.addCutGenerator(&twomirGen,-99,"TwoMirCuts");
    833               OsiSolverInterface * solver = model.solver();
    834 #ifdef COIN_USE_CLP
    835               OsiClpSolverInterface * si =
    836                 dynamic_cast<OsiClpSolverInterface *>(solver) ;
    837               if (preSolve&&si != NULL) {
    838                 // get clp itself
    839                 ClpSimplex * modelC = si->getModelPtr();
    840                 if (si->messageHandler()->logLevel())
    841                   si->messageHandler()->setLogLevel(1);
    842                 if (modelC->tightenPrimalBounds()!=0) {
    843                   std::cout<<"Problem is infeasible!"<<std::endl;
    844                   break;
    845                 }
    846                 model.initialSolve();
    847                 // bounds based on continuous
    848                 if (tightenFactor) {
    849                   if (modelC->tightenPrimalBounds(tightenFactor)!=0) {
    850                     std::cout<<"Problem is infeasible!"<<std::endl;
    851                     break;
    852                   }
    853                 }
    854                 if (gapRatio<1.0e100) {
    855                   double value = si->getObjValue();
    856                   double value2 = gapRatio*(1.0e-5+fabs(value));
    857                   model.setAllowableGap(value2);
    858                   model.setAllowableFractionGap(gapRatio);
    859                   std::cout<<"Continuous "<<value
    860                            <<", so allowable gap set to "<<value2<<std::endl;
    861                 }
    862                 if (djFix<1.0e20) {
    863                   // do some fixing
    864                   int numberColumns = modelC->numberColumns();
    865                   int i;
    866                   const char * type = modelC->integerInformation();
    867                   double * lower = modelC->columnLower();
    868                   double * upper = modelC->columnUpper();
    869                   double * solution = modelC->primalColumnSolution();
    870                   double * dj = modelC->dualColumnSolution();
    871                   for (i=0;i<numberColumns;i++) {
    872                     if (type[i]) {
    873                       double value = solution[i];
    874                       if (value<lower[i]+1.0e-5&&dj[i]>djFix) {
    875                         solution[i]=lower[i];
    876                         upper[i]=lower[i];
    877                       } else if (value>upper[i]-1.0e-5&&dj[i]<-djFix) {
    878                         solution[i]=upper[i];
    879                         lower[i]=upper[i];
    880                       }
    881                     }
    882                   }
    883                 }
    884                 {
    885                   // integer presolve
    886                   if (si->messageHandler()->logLevel())
    887                     si->messageHandler()->setLogLevel(si->messageHandler()->logLevel()-1);
    888                   CbcModel * model2 = model.integerPresolve();
    889                   if (model2) {
    890                     // Do complete search
    891                    
    892                     CbcRounding heuristic1(*model2);
    893                     if (useRounding)
    894                       model2->addHeuristic(&heuristic1);
    895                     OsiClpSolverInterface * si =
    896                       dynamic_cast<OsiClpSolverInterface *>(model2->solver()) ;
    897                     if (si->messageHandler()->logLevel())
    898                       si->messageHandler()->setLogLevel(si->messageHandler()->logLevel()-1);
    899                     CoinSighandler_t saveSignal=SIG_DFL;
    900                     currentBranchModel = model2;
    901                     // register signal handler
    902                     saveSignal = signal(SIGINT,signal_handler);
    903                     model2->branchAndBound() ;
    904                     signal(SIGINT,saveSignal);
    905                     currentBranchModel = NULL;
    906                     // get back solution
    907                     model.originalModel(model2,false);
    908                     delete model2;
    909                   } else {
    910                     // infeasible
    911                     exit(1);
    912                   }
    913                 }
    914               } else
    915 #endif
    916               { if (model.solver()->messageHandler()->logLevel())
    917                   model.solver()->messageHandler()->setLogLevel(1) ;
    918                 model.initialSolve() ;
    919                 if (gapRatio < 1.0e100)
    920                 { double value = model.solver()->getObjValue() ;
    921                   double value2 = gapRatio*(1.0e-5+fabs(value)) ;
    922                   model.setAllowableGap(value2) ;
    923                   std::cout << "Continuous " << value
    924                             << ", so allowable gap set to "
    925                             << value2 << std::endl ; }
    926                 CbcRounding heuristic1(model) ;
    927                 if (useRounding)
    928                   model.addHeuristic(&heuristic1) ;
    929                 if (model.solver()->messageHandler()->logLevel())
    930                   model.solver()->messageHandler()->setLogLevel(model.solver()->messageHandler()->logLevel()-1);
    931                 parameters[slog].setIntValue(parameters[slog].intValue()-1);
    932                 CoinSighandler_t saveSignal=SIG_DFL;
    933                 currentBranchModel = &model;
    934                 // register signal handler
    935                 saveSignal = signal(SIGINT,signal_handler);
    936                 model.branchAndBound() ;
    937                 signal(SIGINT,saveSignal);
    938                 currentBranchModel = NULL;
    939                 model.solver()->messageHandler()->setLogLevel(parameters[slog].intValue());
    940               }
    941                 if (model.bestSolution())
    942                   { std::cout << "Optimal solution "
    943                               << model.solver()->getObjValue() << std::endl ; }
    944                 else
    945                   { std::cout << "No integer solution found." << std::endl ; }
    946                
    947                 time2 = CoinCpuTime() ;
    948                 totalTime += time2-time1 ;
    949                 std::cout << "Result " << model.solver()->getObjValue()
    950                           << " took " << time2-time1 << " seconds - total "
    951                           << totalTime << std::endl ;
    952                 time1 = time2 ;
    953                 // Get solver again
    954 #ifdef COIN_USE_CLP
    955                 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
    956                 lpSolver = clpSolver->getModelPtr();
    957 #endif
     816            if (goodModel) {
     817              // If user made settings then use them
     818              if (!defaultSettings) {
     819                OsiSolverInterface * solver = model.solver();
     820                if (!doScaling)
     821                  solver->setHintParam(OsiDoScale,false,OsiHintTry);
     822                OsiClpSolverInterface * si =
     823                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     824                assert (si != NULL);
     825                // get clp itself
     826                ClpSimplex * modelC = si->getModelPtr();
     827                if (si->messageHandler()->logLevel())
     828                  si->messageHandler()->setLogLevel(1);
     829                if (modelC->tightenPrimalBounds()!=0) {
     830                  std::cout<<"Problem is infeasible!"<<std::endl;
     831                  break;
     832                }
     833                model.initialSolve();
     834                // bounds based on continuous
     835                if (tightenFactor) {
     836                  if (modelC->tightenPrimalBounds(tightenFactor)!=0) {
     837                    std::cout<<"Problem is infeasible!"<<std::endl;
     838                    break;
     839                  }
     840                }
     841                if (djFix<1.0e20) {
     842                  // do some fixing
     843                  int numberColumns = modelC->numberColumns();
     844                  int i;
     845                  const char * type = modelC->integerInformation();
     846                  double * lower = modelC->columnLower();
     847                  double * upper = modelC->columnUpper();
     848                  double * solution = modelC->primalColumnSolution();
     849                  double * dj = modelC->dualColumnSolution();
     850                  int numberFixed=0;
     851                  for (i=0;i<numberColumns;i++) {
     852                    if (type[i]) {
     853                      double value = solution[i];
     854                      if (value<lower[i]+1.0e-5&&dj[i]>djFix) {
     855                        solution[i]=lower[i];
     856                        upper[i]=lower[i];
     857                        numberFixed++;
     858                      } else if (value>upper[i]-1.0e-5&&dj[i]<-djFix) {
     859                        solution[i]=upper[i];
     860                        lower[i]=upper[i];
     861                        numberFixed++;
     862                      }
     863                    }
     864                  }
     865                  printf("%d columns fixed\n",numberFixed);
     866                }
     867              }
     868              // See if we want preprocessing
     869              OsiSolverInterface * saveSolver=NULL;
     870              CglPreProcess process;
     871              if (preProcess) {
     872                saveSolver=model.solver()->clone();
     873                /* Do not try and produce equality cliques and
     874                   do up to 10 passes */
     875                OsiSolverInterface * solver2 = process.preProcess(*saveSolver,false,10);
     876                if (!solver2) {
     877                  printf("Pre-processing says infeasible\n");
     878                  break;
     879                } else {
     880                  printf("processed model has %d rows and %d columns\n",
     881                         solver2->getNumRows(),solver2->getNumCols());
     882                }
     883                //solver2->resolve();
     884                // we have to keep solver2 so pass clone
     885                solver2 = solver2->clone();
     886                model.assignSolver(solver2);
     887                model.initialSolve();
     888              }
     889              CbcRounding heuristic1(model);
     890              if (useRounding)
     891                model.addHeuristic(&heuristic1) ;
     892              // add cut generators if wanted
     893              if (probingAction==1)
     894                model.addCutGenerator(&probingGen,-1,"Probing");
     895              else if (probingAction==2)
     896                model.addCutGenerator(&probingGen,-99,"Probing");
     897              if (gomoryAction==1)
     898                model.addCutGenerator(&gomoryGen,-1,"Gomory");
     899              else if (gomoryAction==2)
     900                model.addCutGenerator(&gomoryGen,-99,"Gomory");
     901              if (knapsackAction==1)
     902                model.addCutGenerator(&knapsackGen,-1,"Knapsack");
     903              else if (knapsackAction==2)
     904                model.addCutGenerator(&knapsackGen,-99,"Knapsack");
     905              if (redsplitAction==1)
     906                model.addCutGenerator(&redsplitGen,-1,"Reduce-and-split");
     907              else if (redsplitAction==2)
     908                model.addCutGenerator(&redsplitGen,-99,"Reduce-and-split");
     909              if (cliqueAction==1)
     910                model.addCutGenerator(&cliqueGen,-1,"Clique");
     911              else if (cliqueAction==2)
     912                model.addCutGenerator(&cliqueGen,-99,"Clique");
     913              if (mixedAction==1)
     914                model.addCutGenerator(&mixedGen,-1,"MixedintegerRounding");
     915              else if (mixedAction==2)
     916                model.addCutGenerator(&mixedGen,-99,"MixedintegerRounding");
     917              if (flowAction==1)
     918                model.addCutGenerator(&flowGen,-1,"FlowCover");
     919              else if (flowAction==2)
     920                model.addCutGenerator(&flowGen,-99,"FlowCover");
     921              if (twomirAction==1)
     922                model.addCutGenerator(&twomirGen,-1,"TwoMirCuts");
     923              else if (twomirAction==2)
     924                model.addCutGenerator(&twomirGen,-99,"TwoMirCuts");
     925              // Say we want timings
     926              int numberGenerators = model.numberCutGenerators();
     927              int iGenerator;
     928              for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
     929                CbcCutGenerator * generator = model.cutGenerator(iGenerator);
     930                generator->setTiming(true);
     931              }
     932              // Could tune more
     933              model.setMinimumDrop(min(1.0,
     934                                        fabs(model.getMinimizationObjValue())*1.0e-3+1.0e-4));
     935             
     936              if (model.getNumCols()<500)
     937                model.setMaximumCutPassesAtRoot(-100); // always do 100 if possible
     938              else if (model.getNumCols()<5000)
     939                model.setMaximumCutPassesAtRoot(100); // use minimum drop
     940              else
     941                model.setMaximumCutPassesAtRoot(20);
     942              model.setMaximumCutPasses(2);
     943             
     944              // Do more strong branching if small
     945              if (model.getNumCols()<5000)
     946                model.setNumberStrong(20);
     947              // Switch off strong branching if wanted
     948              //if (model.getNumCols()>10*model.getNumRows())
     949              //model.setNumberStrong(0);
     950              model.messageHandler()->setLogLevel(parameters[log].intValue());
     951              if (model.getNumCols()>2000||model.getNumRows()>1500||
     952                  model.messageHandler()->logLevel()>1)
     953                model.setPrintFrequency(100);
     954             
     955              model.solver()->setIntParam(OsiMaxNumIterationHotStart,100);
     956              OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     957              // Turn this off if you get problems
     958              // Used to be automatically set
     959              osiclp->setSpecialOptions(128);
     960              // go faster stripes
     961              if (osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
     962                osiclp->setupForRepeatedUse(2,0);
     963              }
     964              if (gapRatio < 1.0e100) {
     965                double value = model.solver()->getObjValue() ;
     966                double value2 = gapRatio*(1.0e-5+fabs(value)) ;
     967                model.setAllowableGap(value2) ;
     968                std::cout << "Continuous " << value
     969                          << ", so allowable gap set to "
     970                          << value2 << std::endl ;
     971              }
     972              currentBranchModel = &model;
     973              model.branchAndBound();
     974              currentBranchModel = NULL;
     975              time2 = CoinCpuTime();
     976              totalTime += time2-time1;
     977              if (model.getMinimizationObjValue()<1.0e50) {
     978                // post process
     979                if (preProcess) {
     980                  process.postProcess(*model.solver());
     981                  // Solution now back in saveSolver
     982                  model.assignSolver(saveSolver);
     983                  clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     984                  lpSolver = clpSolver->getModelPtr();
     985                }
     986              }
     987              std::cout<<"Result "<<model.getObjValue()<<
     988                " iterations "<<model.getIterationCount()<<
     989                " nodes "<<model.getNodeCount()<<
     990                " took "<<time2-time1<<" seconds - total "<<totalTime<<std::endl;
     991              time1 = time2;
     992            } else {
     993              std::cout << "** Current model not valid" << std::endl ;
    958994            }
    959           else
    960             { std::cout << "** Current model not valid" << std::endl ; }
    961           break ; }
     995            break ;
    962996          case IMPORT:
    963997            {
     
    10071041                                                   allowImportErrors!=0);
    10081042                if (!status||(status>0&&allowImportErrors)) {
     1043                  if (keepImportNames) {
     1044                    lengthName = lpSolver->lengthNames();
     1045                    rowNames = *(lpSolver->rowNames());
     1046                    columnNames = *(lpSolver->columnNames());
     1047                  } else {
     1048                    lengthName=0;
     1049                  }
    10091050                  goodModel=true;
    10101051                  //Set integers in clpsolver
     
    16101651                int iRow;
    16111652                int numberRows=lpSolver->numberRows();
    1612                 int lengthName = lpSolver->lengthNames(); // 0 if no names
    1613                 // in general I don't want to pass around massive
    1614                 // amounts of data but seems simpler here
    1615                 std::vector<std::string> rowNames =
    1616                   *(lpSolver->rowNames());
    1617                 std::vector<std::string> columnNames =
    1618                   *(lpSolver->columnNames());
    1619 
    16201653                double * dualRowSolution = lpSolver->dualRowSolution();
    16211654                double * primalRowSolution =
  • trunk/Test/Makefile.solve

    r19 r169  
    3737LibDir += ${bzlibLibDir} ${zlibLibDir} $(lapackLibDir)
    3838
    39 LibName := ${CbcLibName} ${CglLibName}
     39LibName := $(OsiCbcLibName) ${CbcLibName} ${CglLibName}
    4040LibName += ${OsiClpLibName} ${ClpLibName}
     41ifeq ($(VolDefine),COIN_HAS_VOL)
     42LibName += $(VolLibName)
     43endif
    4144#LibName += ${OsiDylpLibName} ${DylpLibName}
    4245LibName += ${OsiLibName} ${CoinLibName}
  • trunk/Test/include/CbcOrClpParam.hpp

    r17 r169  
    5555    MAXFACTOR,PERTVALUE,MAXITERATION,PRESOLVEPASS,IDIOT,SPRINT,
    5656    OUTPUTFORMAT,SLPVALUE,PRESOLVEOPTIONS,PRINTOPTIONS,SPECIALOPTIONS,
    57 
    58     STRONGBRANCHING=151,CUTDEPTH, MAXNODES,
     57    SUBSTITUTION,DUALIZE,
     58
     59    STRONGBRANCHING=151,CUTDEPTH, MAXNODES,NUMBERBEFORE,
    5960#ifdef COIN_USE_CBC
    6061    LOGLEVEL ,
     
    6667   
    6768    NODESTRATEGY = 251,BRANCHSTRATEGY,ADDCUTSSTRATEGY,
    68     GOMORYCUTS,PROBINGCUTS,KNAPSACKCUTS,ODDHOLECUTS,
     69    GOMORYCUTS,PROBINGCUTS,KNAPSACKCUTS,REDSPLITCUTS,
    6970    ROUNDING,SOLVER,CLIQUECUTS,COSTSTRATEGY,FLOWCUTS,MIXEDCUTS,
    70     TWOMIRCUTS,
    71    
    72     DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,
    73     MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,
    74     TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK,REVERSE,BARRIER,NETLIB_BARRIER,
    75     REALLY_SCALE,BASISIN,BASISOUT,SOLVECONTINUOUS,CLEARCUTS,VERSION,
     71    TWOMIRCUTS,PREPROCESS,
     72   
     73    DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,EITHERSIMPLEX,
     74    MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_EITHER,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,
     75    TIGHTEN,FAKEBOUND,HELP,PLUSMINUS,NETWORK,ALLSLACK,REVERSE,BARRIER,NETLIB_BARRIER,NETLIB_TUNE,
     76    REALLY_SCALE,BASISIN,BASISOUT,SOLVECONTINUOUS,CLEARCUTS,VERSION,STATISTICS,
    7677
    7778    BAB=351,MIPLIB,
     
    8081
    8182    INVALID = 1000 } ;
    82 
    8383#include <vector>
    8484#include <string>
     
    8989{
    9090public:
    91 
    9291  /**@name Constructor and destructor */
    9392  //@{
Note: See TracChangeset for help on using the changeset viewer.