Ignore:
Timestamp:
Oct 8, 2006 7:33:47 PM (13 years ago)
Author:
forrest
Message:

towards common use with other solvers

File:
1 edited

Legend:

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

    r435 r439  
    3636#include "CbcOrClpParam.hpp"
    3737#include "OsiRowCutDebugger.hpp"
     38#include "OsiChooseVariable.hpp"
    3839#ifdef DMALLOC
    3940#include "dmalloc.h"
     
    495496  const double * rowLower = solver->getRowLower();
    496497  const double * rowUpper = solver->getRowUpper();
    497   CbcObject ** objects = babModel->objects();
     498  OsiObject ** objects = babModel->objects();
    498499  int numberObjects = babModel->numberObjects();
    499500  for (int iObj = 0;iObj<numberObjects;iObj++) {
     
    742743    parameters[whichParam(CUTSSTRATEGY,numberParameters,parameters)].setCurrentOption("on");
    743744    parameters[whichParam(HEURISTICSTRATEGY,numberParameters,parameters)].setCurrentOption("on");
     745    parameters[whichParam(NODESTRATEGY,numberParameters,parameters)].setCurrentOption("fewest");
     746    int nodeStrategy=0;
    744747    int doSOS=1;
    745748    int verbose=0;
     
    13071310              mixedAction = action;
    13081311              twomirAction = action;
    1309               landpAction = action;
     1312              //landpAction = action;
    13101313              parameters[whichParam(GOMORYCUTS,numberParameters,parameters)].setCurrentOption(action);
    13111314              parameters[whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption(action);
     
    13501353            case COSTSTRATEGY:
    13511354              useCosts=action;
     1355              break;
     1356            case NODESTRATEGY:
     1357              nodeStrategy=action;
    13521358              break;
    13531359            case PREPROCESS:
     
    20572063              if (useFpump) {
    20582064                heuristic4.setMaximumPasses(parameters[whichParam(FPUMPITS,numberParameters,parameters)].intValue());
    2059                 if (doIdiot>10&&doIdiot<14) {
    2060                   heuristic4.setWhen(doIdiot);
    2061                   doIdiot=-1;
     2065                int pumpTune=parameters[whichParam(FPUMPTUNE,numberParameters,parameters)].intValue();
     2066                if (pumpTune>10) {
     2067                  /*
     2068                    >=1000 use index+2 as number of large loops, if >4 decrement by 5 and clean used array
     2069                    >=100 use 0.05 objvalue as increment
     2070                    >=10 use +0.1 objvalue for cutoff (add)
     2071                    1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds
     2072                  */
     2073                  if (pumpTune) {
     2074                    double value = babModel->solver()->getObjSense()*babModel->solver()->getObjValue();
     2075                    int w = pumpTune/10;
     2076                    int c = w % 10;
     2077                    w /= 10;
     2078                    int i = w % 10;
     2079                    w /= 10;
     2080                    int r = w%10;
     2081                    // fake cutoff
     2082                    if (c) {
     2083                      double cutoff;
     2084                      babModel->solver()->getDblParam(OsiDualObjectiveLimit,cutoff);
     2085                      cutoff = CoinMin(cutoff,value + 0.1*fabs(value)*c);
     2086                      heuristic4.setFakeCutoff(cutoff);
     2087                    }
     2088                    if (i||r) {
     2089                      // also set increment
     2090                      heuristic4.setAbsoluteIncrement((0.01*i+0.005)*(fabs(value)+1.0e-12));
     2091                      if (r>4) {
     2092                        r -=5;
     2093                        heuristic4.setMaximumRetries(-r-2);
     2094                      } else {
     2095                        heuristic4.setMaximumRetries(r+2);
     2096                      }
     2097                    }
     2098                    pumpTune = pumpTune%100;
     2099                    heuristic4.setWhen(pumpTune+10);
     2100                  }
    20622101                }
    20632102                babModel->addHeuristic(&heuristic4);
     
    20852124              int switches[20];
    20862125              int numberGenerators=0;
    2087               int translate[6]={-100,-1,-99,-98,1,1};
     2126              int translate[]={-100,-1,-99,-98,1,1,1,1};
    20882127              if (probingAction) {
    2089                 if (probingAction==5)
     2128                if (probingAction==5||probingAction==7)
    20902129                  probingGen.setRowCuts(-3); // strengthening etc just at root
    2091                 if (probingAction==4) {
     2130                if (probingAction==6||probingAction==7) {
    20922131                  // Number of unsatisfied variables to look at
    20932132                  probingGen.setMaxProbe(1000);
     
    21712210              //babModel->setNumberStrong(0);
    21722211              if (!noPrinting) {
     2212                int iLevel = parameters[log].intValue();
     2213                if (iLevel<0) {
     2214                  babModel->setPrintingMode(1);
     2215                  iLevel = -iLevel;
     2216                }
    21732217                babModel->messageHandler()->setLogLevel(parameters[log].intValue());
    21742218                if (babModel->getNumCols()>2000||babModel->getNumRows()>1500||
     
    22992343                    numberIntegers = babModel->numberIntegers();
    23002344                  }
    2301                   CbcObject ** oldObjects = babModel->objects();
     2345                  OsiObject ** oldObjects = babModel->objects();
    23022346                  // Do sets and priorities
    2303                   CbcObject ** objects = new CbcObject * [numberSOS];
     2347                  OsiObject ** objects = new OsiObject * [numberSOS];
    23042348                  // set old objects to have low priority
    23052349                  int numberOldObjects = babModel->numberObjects();
     
    23132357                    if (originalColumns)
    23142358                      iColumn = originalColumns[iColumn];
    2315                     if (branchDirection)
    2316                       oldObjects[iObj]->setPreferredWay(branchDirection[iColumn]);
     2359                    if (branchDirection) {
     2360                      CbcSimpleInteger * obj =
     2361                        dynamic_cast <CbcSimpleInteger *>(oldObjects[iObj]) ;
     2362                      if (obj) {
     2363                        obj->setPreferredWay(branchDirection[iColumn]);
     2364                      } else {
     2365                        CbcObject * obj =
     2366                          dynamic_cast <CbcObject *>(oldObjects[iObj]) ;
     2367                        assert (obj);
     2368                        obj->setPreferredWay(branchDirection[iColumn]);
     2369                      }
     2370                    }
    23172371                    if (pseudoUp) {
    23182372                      CbcSimpleIntegerPseudoCost * obj1a =
     
    23542408                  if (numberSOS) {
    23552409                    // Do sets and priorities
    2356                     CbcObject ** objects = new CbcObject * [numberSOS];
     2410                    OsiObject ** objects = new OsiObject * [numberSOS];
    23572411                    int iSOS;
    23582412                    if (originalColumns) {
     
    23962450                    delete [] objects;
    23972451                  }
    2398                   CbcObject ** objects = babModel->objects();
     2452                  OsiObject ** objects = babModel->objects();
    23992453                  int numberObjects = babModel->numberObjects();
    24002454                  for (int iObj = 0;iObj<numberObjects;iObj++) {
     
    24082462                    if (originalColumns)
    24092463                      iColumn = originalColumns[iColumn];
    2410                     if (branchDirection)
    2411                       objects[iObj]->setPreferredWay(branchDirection[iColumn]);
     2464                    if (branchDirection) {
     2465                      CbcSimpleInteger * obj =
     2466                        dynamic_cast <CbcSimpleInteger *>(objects[iObj]) ;
     2467                      if (obj) {
     2468                        obj->setPreferredWay(branchDirection[iColumn]);
     2469                      } else {
     2470                        CbcObject * obj =
     2471                          dynamic_cast <CbcObject *>(objects[iObj]) ;
     2472                        assert (obj);
     2473                        obj->setPreferredWay(branchDirection[iColumn]);
     2474                      }
     2475                    }
    24122476                    if (priorities) {
    24132477                      int iPriority = priorities[iColumn];
     
    24552519                }
    24562520#endif               
     2521                if (nodeStrategy) {
     2522                  // change default
     2523                  if (nodeStrategy>1) {
     2524                    // up or down
     2525                    int way = ((nodeStrategy%1)==1) ? -1 : +1;
     2526                    babModel->setPreferredWay(way);
     2527#if 0
     2528                    OsiObject ** objects = babModel->objects();
     2529                    int numberObjects = babModel->numberObjects();
     2530                    for (int iObj = 0;iObj<numberObjects;iObj++) {
     2531                      CbcObject * obj =
     2532                        dynamic_cast <CbcObject *>(objects[iObj]) ;
     2533                      assert (obj);
     2534                      obj->setPreferredWay(way);
     2535                    }
     2536#endif
     2537                  }
     2538                  if (nodeStrategy==1||nodeStrategy>3) {
     2539                    // depth
     2540                    CbcCompareDefault compare;
     2541                    compare.setWeight(-3.0);
     2542                    babModel->setNodeComparison(compare);
     2543                  }
     2544                }
    24572545                if (cppValue>=0) {
    24582546                  int prepro = useStrategy ? -1 : preProcess;
     
    24802568                  strategy.setupPreProcessing(1);
    24812569                  babModel->setStrategy(strategy);
     2570                }
     2571                int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
     2572                if (testOsiOptions>0) {
     2573                  printf("Testing OsiObject options %d\n",testOsiOptions);
     2574                  CbcBranchDefaultDecision decision;
     2575                  OsiChooseVariable choose(babModel->solver());
     2576                  decision.setChooseMethod(choose);
     2577                  babModel->setBranchingMethod(decision);
    24822578                }
    24832579                checkSOS(babModel, babModel->solver());
     
    45714667  std::string header[9]=
    45724668  { "","Save values","Redundant save of default values","Set changed values",
    4573     "Redundant set default values","Solve","Restore values","Redundant restore values","Add to model"};
     4669    "Redundant set default values","Solve","Restore values","Redundant restore values","Finish up"};
    45744670  for (int iType=0;iType<9;iType++) {
    45754671    if (!wanted[iType])
Note: See TracChangeset for help on using the changeset viewer.