Ignore:
Timestamp:
Nov 6, 2014 11:17:38 AM (5 years ago)
Author:
forrest
Message:

changes for diving heuristic

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcSolver.cpp

    r2092 r2093  
    18361836            int iParam;
    18371837            iParam = whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_);
    1838             parameters_[iParam].setIntValue(3);
     1838            parameters_[iParam].setIntValue(2);
    18391839            iParam = whichParam(CBC_PARAM_INT_FPUMPITS, numberParameters_, parameters_);
    18401840            parameters_[iParam].setIntValue(30);
     
    32193219                              model_.flipModel();
    32203220                            //if we do then - fix priorities in clonebutmodel_.convertToDynamic();
     3221                            bool objectsExist = model_.objects() != NULL;
     3222                            if (!objectsExist) {
     3223                              model_.findIntegers(false);
     3224                              model_.convertToDynamic();
     3225                            }
     3226                            // set priorities etc
     3227                            if (priorities) {
     3228                              OsiObject ** objects = model_.objects();
     3229                              int numberObjects = model_.numberObjects();
     3230                              for (int iObj = 0; iObj < numberObjects; iObj++) {
     3231                                CbcSimpleInteger * obj =
     3232                                  dynamic_cast <CbcSimpleInteger *>(objects[iObj]) ;
     3233                                if (!obj)
     3234                                  continue;
     3235                                int iColumn = obj->columnNumber();
     3236                                if (branchDirection) {
     3237                                  obj->setPreferredWay(branchDirection[iColumn]);
     3238                                }
     3239                                if (priorities) {
     3240                                  int iPriority = priorities[iColumn];
     3241                                  if (iPriority > 0)
     3242                                    obj->setPriority(iPriority);
     3243                                }
     3244                                if (pseudoUp && pseudoUp[iColumn]) {
     3245                                  CbcSimpleIntegerPseudoCost * obj1a =
     3246                                    dynamic_cast <CbcSimpleIntegerPseudoCost *>(objects[iObj]) ;
     3247                                  assert (obj1a);
     3248                                  if (pseudoDown[iColumn] > 0.0)
     3249                                    obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     3250                                  if (pseudoUp[iColumn] > 0.0)
     3251                                    obj1a->setUpPseudoCost(pseudoUp[iColumn]);
     3252                                }
     3253                              }
     3254                            }
    32213255                            doHeuristics(&model_, 2, parameters_,
    32223256                                         numberParameters_, noPrinting_, initialPumpTune);
     3257                            if (!objectsExist) {
     3258                              model_.deleteObjects(false);
     3259                            }
    32233260                            if (needFlip)
    32243261                              model_.flipModel();
     
    79748011                                int got[] = { -1, -1, -1, -1, -1, -1, -1, -1};
    79758012                                int order[8];
     8013                                bool useMasks = false;
     8014                                if (strstr(fileName.c_str(),"mask_")) {
     8015                                  // look more closely
     8016                                  const char * name = fileName.c_str();
     8017                                  int length = strlen(name);
     8018                                  for (int i=length-1;i>=0;i--) {
     8019                                    if (name[i]==dirsep) {
     8020                                      name += i+1;
     8021                                      break;
     8022                                    }
     8023                                  }
     8024                                  useMasks = !strncmp(name,"mask_",5);
     8025                                }
    79768026                                assert(sizeof(got) == sizeof(order));
    79778027                                int nAcross = 0;
     
    80408090                                    if (good) {
    80418091                                        char ** columnNames = new char * [numberColumns];
    8042                                         pseudoDown = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
    8043                                         pseudoUp = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
    8044                                         branchDirection = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
     8092                                        //pseudoDown = NULL;
     8093                                        //pseudoUp = NULL;
     8094                                        //branchDirection = NULL;
     8095                                        //if (got[5]!=-1)
     8096                                          pseudoDown = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
     8097                                          //if (got[4]!=-1)
     8098                                          pseudoUp = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
     8099                                          //if (got[2]!=-1)
     8100                                          branchDirection = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
    80458101                                        priorities = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
    80468102                                        free(solutionIn);
     
    80628118                                            columnNames[iColumn] =
    80638119                                                CoinStrdup(lpSolver->columnName(iColumn).c_str());
    8064                                             pseudoDown[iColumn] = 0.0;
    8065                                             pseudoUp[iColumn] = 0.0;
    8066                                             branchDirection[iColumn] = 0;
    8067                                             priorities[iColumn] = 0;
     8120                                            //if (got[5]!=-1)
     8121                                              pseudoDown[iColumn] = 0.0;
     8122                                              //if (got[4]!=-1)
     8123                                              pseudoUp[iColumn] = 0.0;
     8124                                              //if (got[2]!=-1)
     8125                                              branchDirection[iColumn] = 0;
     8126                                            priorities[iColumn] = useMasks ? -123456789 : 0;
    80688127                                        }
    80698128                                        int nBadPseudo = 0;
     
    80738132                                        int nBadLine = 0;
    80748133                                        int nLine = 0;
    8075                                         while (fgets(line, 1000, fp)) {
     8134                                        iColumn = -1;
     8135                                        int lowestPriority=-COIN_INT_MAX;
     8136                                        while (iColumn>=0 || fgets(line, 1000, fp)) {
    80768137                                            if (!strncmp(line, "ENDATA", 6))
    80778138                                                break;
    80788139                                            nLine++;
    8079                                             iColumn = -1;
     8140                                            if (!useMasks)
     8141                                              iColumn = -1;
    80808142                                            double up = 0.0;
    80818143                                            double down = 0.0;
     
    81158177                                                    // name
    81168178                                                case 0:
    8117                                                     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     8179                                                  iColumn++;
     8180                                                  for (; iColumn < numberColumns; iColumn++) {
     8181                                                      if (priorities[iColumn]!=-123456789) {
    81188182                                                        if (!strcmp(columnNames[iColumn], pos))
    81198183                                                            break;
     8184                                                      } else {
     8185                                                        // mask (at present ? and trailing *)
     8186                                                        const char * name = columnNames[iColumn];
     8187                                                        int length=strlen(name);
     8188                                                        int lengthMask=strlen(pos);
     8189                                                        bool asterisk = pos[lengthMask-1]=='*';
     8190                                                        if (asterisk)
     8191                                                          length=lengthMask-1;
     8192                                                        int i;
     8193                                                        for (i=0;i<length;i++) {
     8194                                                          if (name[i]!=pos[i]) {
     8195                                                            if (pos[i]!='?')
     8196                                                              break;
     8197                                                          }
     8198                                                        }
     8199                                                        if (i==length)
     8200                                                          break;
     8201                                                      }
    81208202                                                    }
    81218203                                                    if (iColumn == numberColumns)
     
    81488230                                                case 3:
    81498231                                                    pri = atoi(pos);
     8232                                                    lowestPriority=CoinMax(lowestPriority,pri);
    81508233                                                    break;
    81518234                                                    // up
     
    81928275                                                    pri = 0;
    81938276                                                }
    8194                                                 pseudoDown[iColumn] = down;
    8195                                                 pseudoUp[iColumn] = up;
    8196                                                 branchDirection[iColumn] = dir;
     8277                                                //if (got[5]!=-1)
     8278                                                  pseudoDown[iColumn] = down;
     8279                                                  //if (got[4]!=-1)
     8280                                                  pseudoUp[iColumn] = up;
     8281                                                  //if (got[2]!=-1)
     8282                                                  branchDirection[iColumn] = dir;
    81978283                                                priorities[iColumn] = pri;
    81988284                                                if (solValue != COIN_DBL_MAX) {
     
    82048290                                                    prioritiesIn[iColumn] = priValue;
    82058291                                                }
    8206                                             } else {
     8292                                            } else if (!useMasks) {
    82078293                                                nBadName++;
    82088294                                            }
     8295                                        }
     8296                                        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     8297                                          if (priorities[iColumn] == -123456789)
     8298                                            priorities[iColumn] = lowestPriority+1;
    82098299                                        }
    82108300                                        if (!noPrinting_) {
Note: See TracChangeset for help on using the changeset viewer.