Changeset 503 for branches/devel/Cbc/src


Ignore:
Timestamp:
Dec 19, 2006 2:27:11 PM (13 years ago)
Author:
forrest
Message:

quadratic

Location:
branches/devel/Cbc/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Cbc/src/CbcLinked.cpp

    r502 r503  
    329329    }
    330330    if (isProvenOptimal()) {
    331       if (satisfied)
    332         printf("satisfied %d\n",satisfied);
     331      //if (satisfied==2)
     332      //printf("satisfied %d\n",satisfied);
    333333      if (satisfied&&(specialOptions2_&2)!=0) {
    334334        assert (quadraticModel_);
     
    568568                  int xColumn = obj->xColumn();
    569569                  int yColumn = obj->yColumn();
    570                   // We can do better if one fixed
    571                   assert (columnUpper[xColumn]>columnLower[xColumn]);
    572                   assert (columnUpper[yColumn]>columnLower[yColumn]);
    573570                  if (xColumn!=yColumn) {
    574571                    double coefficient = 2.0*obj->coefficient();
     
    648645                int xColumn = obj->xColumn();
    649646                int yColumn = obj->yColumn();
    650                 // We can do better if one fixed
    651                 assert (columnUpper[xColumn]>columnLower[xColumn]);
    652                 assert (columnUpper[yColumn]>columnLower[yColumn]);
    653647                if (xColumn!=yColumn) {
    654648                  double coefficient = 2.0*obj->coefficient();
     
    10921086      numberQuadratic=0;
    10931087    }
    1094     if (quadraticObjective||((specialOptions2_&8)!=0&&saveNBi)) {
     1088    //if (quadraticObjective||((specialOptions2_&8)!=0&&saveNBi)) {
     1089    if (saveNBi) {
    10951090      // add in objective as constraint
    10961091      objectiveVariable_= numberColumns;
     
    15581553      convex_[iNon]=0;
    15591554    }
    1560     printf("Convexity of row %d is %d\n",iRow,convex_[iNon]);
     1555    //printf("Convexity of row %d is %d\n",iRow,convex_[iNon]);
    15611556    delete [] iColumn;
    15621557    delete [] jColumn;
  • branches/devel/Cbc/src/CoinSolve.cpp

    r497 r503  
    8484#include "CbcHeuristicGreedy.hpp"
    8585#include "CbcHeuristicFPump.hpp"
     86#include "CbcHeuristicRINS.hpp"
    8687#include "CbcTreeLocal.hpp"
    8788#include "CbcCompareActual.hpp"
     
    105106#endif
    106107//#############################################################################
    107 // To use USERCBC uncomment the following define and add in your fake main program here
     108// To use USERCBC or USERCLP uncomment the following define and add in your fake main program here
    108109//#define USER_HAS_FAKE_MAIN
    109110//  Start any fake main program
     
    586587    int tunePreProcess=5;
    587588    int testOsiParameters=-1;
    588     bool quadraticInteger=false;
     589    // 0 normal, 1 from ampl, 2 from other input
     590    int complicatedInteger=0;
    589591    OsiSolverInterface * solver = model.solver();
    590592    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    662664        clpSolver->messageHandler()->setLogLevel(0) ;
    663665        testOsiParameters=0;
    664         quadraticInteger=true;
     666        complicatedInteger=1;
    665667      }
    666668#endif
     
    836838    // set default action (0=off,1=on,2=root)
    837839    // Off as seems to give some bad cuts
    838     int redsplitAction=2;
    839     parameters[whichParam(REDSPLITCUTS,numberParameters,parameters)].setCurrentOption("root");
     840    int redsplitAction=0;
     841    parameters[whichParam(REDSPLITCUTS,numberParameters,parameters)].setCurrentOption("off");
    840842
    841843    CglClique cliqueGen(false,true);
     
    878880    parameters[whichParam(COMBINE,numberParameters,parameters)].setCurrentOption("on");
    879881    bool useLocalTree=false;
     882    bool useRINS=false;
     883    parameters[whichParam(RINS,numberParameters,parameters)].setCurrentOption("off");
    880884    parameters[whichParam(COSTSTRATEGY,numberParameters,parameters)].setCurrentOption("off");
    881885    int useCosts=0;
     
    13551359              useFpump=action;
    13561360              break;
     1361            case RINS:
     1362              useRINS=action;
     1363              break;
    13571364            case CUTSSTRATEGY:
    13581365              gomoryAction = action;
     
    17861793                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
    17871794                ClpSimplex * clpSolver = si->getModelPtr();
    1788                 if (!quadraticInteger&&clpSolver->tightenPrimalBounds()!=0) {
     1795                if (!complicatedInteger&&clpSolver->tightenPrimalBounds()!=0) {
    17891796                  std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
    17901797                  exit(1);
     
    20042011                    delete [] prohibited;
    20052012                  }
    2006                   solver2 = process.preProcessNonDefault(*saveSolver,translate[preProcess],10,
     2013                  int numberPasses = 10;
     2014                  if (tunePreProcess>=1000) {
     2015                    numberPasses = (tunePreProcess/1000)-1;
     2016                    tunePreProcess = tunePreProcess % 1000;
     2017                  }
     2018                  solver2 = process.preProcessNonDefault(*saveSolver,translate[preProcess],numberPasses,
    20072019                                                         tunePreProcess);
    20082020                  // Tell solver we are not in Branch and Cut
     
    20532065                if (noPrinting)
    20542066                  modelC->setLogLevel(0);
    2055                 if (!quadraticInteger&&modelC->tightenPrimalBounds()!=0) {
     2067                if (!complicatedInteger&&modelC->tightenPrimalBounds()!=0) {
    20562068                  std::cout<<"Problem is infeasible!"<<std::endl;
    20572069                  break;
     
    21942206                }
    21952207              }
     2208              CbcHeuristicRINS heuristic5(*babModel);
     2209              if (useRINS)
     2210                babModel->addHeuristic(&heuristic5) ;
    21962211              if (type==MIPLIB) {
    21972212                if (babModel->numberStrong()==5&&babModel->numberBeforeTrust()==5)
     
    22162231                switches[numberGenerators++]=0;
    22172232              }
    2218               if (gomoryAction) {
     2233              if (gomoryAction&&!complicatedInteger) {
    22192234                babModel->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
    22202235                switches[numberGenerators++]=-1;
     
    22242239                switches[numberGenerators++]=0;
    22252240              }
    2226               if (redsplitAction) {
     2241              if (redsplitAction&&!complicatedInteger) {
    22272242                babModel->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");
    22282243                switches[numberGenerators++]=1;
     
    22402255                switches[numberGenerators++]=1;
    22412256              }
    2242               if (twomirAction) {
     2257              if (twomirAction&&!complicatedInteger) {
    22432258                babModel->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");
    22442259                switches[numberGenerators++]=1;
     
    28412856                  printf("Testing OsiObject options %d\n",testOsiOptions);
    28422857                  CbcBranchDefaultDecision decision;
     2858                  OsiChooseStrong choose(babModel->solver());
     2859                  choose.setNumberBeforeTrusted(babModel->numberBeforeTrust());
     2860                  choose.setNumberStrong(babModel->numberStrong());
     2861                  choose.setShadowPriceMode(testOsiOptions);
    28432862                  if (!numberSOS) {
    28442863                    babModel->solver()->findIntegersAndSOS(false);
     2864                    // If linked then pass in model
     2865                    OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel->solver());
     2866                    if (solver3) {
     2867                      solver3->setCbcModel(babModel);
     2868                      CglStored stored;
     2869                      babModel->addCutGenerator(&stored,1,"Stored");
     2870                      CglTemporary temp;
     2871                      babModel->addCutGenerator(&temp,1,"OnceOnly");
     2872                      choose.setNumberBeforeTrusted(2000);
     2873                      choose.setNumberStrong(20);
     2874                    }
    28452875                  } else {
    28462876                    // move across
     
    28482878                    //babModel->addObjects(babModel->solver()->numberObjects(),babModel->solver()->objects());
    28492879                  }
    2850                   //OsiChooseVariable choose(babModel->solver());
    2851                   OsiChooseStrong choose(babModel->solver());
    2852                   choose.setNumberBeforeTrusted(babModel->numberBeforeTrust());
    2853                   choose.setNumberStrong(babModel->numberStrong());
    2854                   choose.setShadowPriceMode(testOsiOptions);
    28552880                  decision.setChooseMethod(choose);
    28562881                  babModel->setBranchingMethod(decision);
     
    31673192              }
    31683193            }
     3194            break;
     3195          case MODELIN:
     3196#ifdef COIN_HAS_LINK
     3197            {
     3198              // get next field
     3199              field = CoinReadGetString(argc,argv);
     3200              if (field=="$") {
     3201                field = parameters[iParam].stringValue();
     3202              } else if (field=="EOL") {
     3203                parameters[iParam].printString();
     3204                break;
     3205              } else {
     3206                parameters[iParam].setStringValue(field);
     3207              }
     3208              std::string fileName;
     3209              bool canOpen=false;
     3210              if (field=="-") {
     3211                // stdin
     3212                canOpen=true;
     3213                fileName = "-";
     3214              } else {
     3215                bool absolutePath;
     3216                if (dirsep=='/') {
     3217                  // non Windows (or cygwin)
     3218                  absolutePath=(field[0]=='/');
     3219                } else {
     3220                  //Windows (non cycgwin)
     3221                  absolutePath=(field[0]=='\\');
     3222                  // but allow for :
     3223                  if (strchr(field.c_str(),':'))
     3224                    absolutePath=true;
     3225                }
     3226                if (absolutePath) {
     3227                  fileName = field;
     3228                } else if (field[0]=='~') {
     3229                  char * environVar = getenv("HOME");
     3230                  if (environVar) {
     3231                    std::string home(environVar);
     3232                    field=field.erase(0,1);
     3233                    fileName = home+field;
     3234                  } else {
     3235                    fileName=field;
     3236                  }
     3237                } else {
     3238                  fileName = directory+field;
     3239                }
     3240                FILE *fp=fopen(fileName.c_str(),"r");
     3241                if (fp) {
     3242                  // can open - lets go for it
     3243                  fclose(fp);
     3244                  canOpen=true;
     3245                } else {
     3246                  std::cout<<"Unable to open file "<<fileName<<std::endl;
     3247                }
     3248              }
     3249              if (canOpen) {
     3250                CoinModel coinModel(fileName.c_str(),2);
     3251                // load from coin model
     3252                OsiSolverLink solver1;
     3253                OsiSolverInterface * solver2 = solver1.clone();
     3254                model.assignSolver(solver2,true);
     3255                OsiSolverLink * si =
     3256                  dynamic_cast<OsiSolverLink *>(model.solver()) ;
     3257                assert (si != NULL);
     3258                si->setDefaultMeshSize(0.001);
     3259                // need some relative granularity
     3260                si->setDefaultBound(100.0);
     3261                si->setDefaultMeshSize(0.01);
     3262                si->setDefaultBound(100.0);
     3263                si->setIntegerPriority(1000);
     3264                si->setBiLinearPriority(10000);
     3265                CoinModel * model2 = (CoinModel *) &coinModel;
     3266                si->load(*model2);
     3267                // redo
     3268                solver = model.solver();
     3269                clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     3270                lpSolver = clpSolver->getModelPtr();
     3271                clpSolver->messageHandler()->setLogLevel(0) ;
     3272                testOsiParameters=0;
     3273                complicatedInteger=2;
     3274              }
     3275            }
     3276#endif
    31693277            break;
    31703278          case EXPORT:
     
    40154123            // Replace the sample code by whatever you want
    40164124            if (goodModel) {
     4125#ifndef USER_HAS_FAKE_MAIN
    40174126              printf("Dummy user clp code - model has %d rows and %d columns\n",
    40184127                     lpSolver->numberRows(),lpSolver->numberColumns());
     4128#else
     4129              // Way of using an existing piece of code
     4130              OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     4131              ClpSimplex * lpSolver = clpSolver->getModelPtr();
     4132              // set time from integer model
     4133              double timeToGo = model.getMaximumSeconds();
     4134              lpSolver->setMaximumSeconds(timeToGo);
     4135              fakeMain2(*lpSolver,*clpSolver);
     4136#ifdef COIN_HAS_ASL
     4137              // My actual usage has objective only in clpSolver
     4138              double objectiveValue=clpSolver->getObjValue();
     4139              int iStat = lpSolver->status();
     4140              int iStat2 = lpSolver->secondaryStatus();
     4141#endif
     4142#endif
    40194143            }
    40204144            break;
Note: See TracChangeset for help on using the changeset viewer.