Changeset 2357


Ignore:
Timestamp:
Jan 19, 2018 10:12:47 AM (5 weeks ago)
Author:
forrest
Message:

changes for SC

Location:
trunk/Cbc/src
Files:
4 edited

Legend:

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

    r2355 r2357  
    43034303        goToDantzig(100, savePivotMethod);
    43044304#endif
     4305        //#define REPORT_DYNAMIC 2
     4306#if REPORT_DYNAMIC
     4307        if (numberNodes_&&!parentModel_&&(tree_->empty()||(numberNodes_%10000)==0)) {
     4308          // Get average up and down costs
     4309          double averageUp = 0.0;
     4310          double averageDown = 0.0;
     4311          int numberUp = 0;
     4312          int numberDown = 0;
     4313          int minTimesDown = COIN_INT_MAX;
     4314          int maxTimesDown = 0;
     4315          int neverBranchedDown = 0;
     4316          int infeasibleTimesDown = 0;
     4317          int minTimesUp = COIN_INT_MAX;
     4318          int maxTimesUp = 0;
     4319          int infeasibleTimesUp = 0;
     4320          int neverBranchedUp = 0;
     4321          int neverBranched = 0;
     4322          int i;
     4323          int numberInts=0;
     4324          bool endOfSearch = tree_->empty();
     4325          int  numberUp2 = 0;
     4326          int numberDown2 = 0;
     4327          for ( i = 0; i < numberObjects_; i++) {
     4328            OsiObject * object = object_[i];
     4329            CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
     4330              dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
     4331            if (dynamicObject) {
     4332              numberInts++;
     4333              if (dynamicObject->numberTimesUp()||
     4334                  dynamicObject->numberTimesDown()) {
     4335                int  nUp = 0;
     4336                int nDown = 0;
     4337                double up = 0.0;
     4338                double down = 0.0;
     4339                if (dynamicObject->numberTimesUp()) {
     4340                  numberUp++;
     4341                  nUp = dynamicObject->numberTimesUp();
     4342                  minTimesUp = CoinMin(minTimesUp,nUp);
     4343                  maxTimesUp = CoinMax(maxTimesUp,nUp);
     4344                  up = dynamicObject->upDynamicPseudoCost();
     4345                  averageUp += up;
     4346                  numberUp2 += nUp;
     4347                  infeasibleTimesUp += dynamicObject->numberTimesUpInfeasible();
     4348                } else {
     4349                  neverBranchedUp++;
     4350                }
     4351                if (dynamicObject->numberTimesDown()) {
     4352                  numberDown++;
     4353                  nDown = dynamicObject->numberTimesDown();
     4354                  minTimesDown = CoinMin(minTimesDown,nDown);
     4355                  maxTimesDown = CoinMax(maxTimesDown,nDown);
     4356                  down = dynamicObject->downDynamicPseudoCost();
     4357                  averageDown += down;
     4358                  numberDown2 += dynamicObject->numberTimesDown();
     4359                  infeasibleTimesDown += dynamicObject->numberTimesDownInfeasible();
     4360                } else {
     4361                  neverBranchedDown++;
     4362                }
     4363#if REPORT_DYNAMIC > 1
     4364#if REPORT_DYNAMIC == 2
     4365                if (endOfSearch&&numberIntegers_<400) {
     4366#elif REPORT_DYNAMIC == 3
     4367                if (endOfSearch) {
     4368#else
     4369                  {
     4370#endif
     4371                  dynamicObject->print(0,0.0);
     4372                }
     4373#endif
     4374              } else {
     4375                neverBranched++;
     4376#if REPORT_DYNAMIC > 2
     4377#if REPORT_DYNAMIC == 3
     4378                if (endOfSearch&&numberIntegers_<400) {
     4379#elif REPORT_DYNAMIC == 4
     4380                if (endOfSearch) {
     4381#else
     4382                  {
     4383#endif
     4384                  printf("col %d - never branched on\n",dynamicObject->columnNumber());
     4385                }
     4386#endif
     4387              }
     4388            }
     4389          }
     4390          if (numberUp)
     4391            averageUp /= static_cast<double> (numberUp);
     4392          else
     4393            averageUp = 0.0;
     4394          if (numberDown)
     4395            averageDown /= static_cast<double> (numberDown);
     4396          else
     4397            averageDown = 0.0;
     4398          printf("Report for %d variables (%d never branched on) after %d nodes - total solves down %d up %d\n",
     4399                 numberInts,neverBranched,numberNodes_,numberDown2,numberUp2);
     4400          if ((neverBranchedDown||neverBranchedUp)&&endOfSearch)
     4401            printf("odd %d never branched down and %d never branched up\n",
     4402                   neverBranchedDown,neverBranchedUp);
     4403          printf("down average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n",
     4404                 static_cast<double>(numberDown2)/numberDown,infeasibleTimesDown,averageDown,
     4405                 minTimesDown,maxTimesDown);
     4406          printf("up average %g times (%d infeasible) average increase %g min/max times (%d,%d)\n",
     4407                 static_cast<double>(numberUp2)/numberUp,infeasibleTimesUp,averageUp,
     4408                 minTimesUp,maxTimesUp);
     4409        }
     4410#endif
    43054411        if (tree_->empty()) {
    43064412#ifdef CBC_THREAD
     
    79868092            // Care! We must be careful not to update the same variable in parallel threads.
    79878093            addUpdateInformation(update);
     8094            // update here
     8095            {
     8096              CbcObject * object = dynamic_cast<CbcObject *> (update.object_);
     8097              if (object)
     8098                object->updateInformation(update);
     8099            }
    79888100            //#define CBCMODEL_TIGHTEN_BOUNDS
    79898101#ifdef CBCMODEL_TIGHTEN_BOUNDS
     
    1517915291                    assert (found);
    1518015292#endif
    15181                     //if (object)
    15182                     //assert (object==object_[update->objectNumber_]);
    1518315293                    if (object)
    1518415294                        object->updateInformation(*update);
     
    1709917209                    assert (found);
    1710017210#endif
    17101                     //if (object)
    17102                     //assert (object==object_[update->objectNumber_]);
    1710317211                    if (object)
    1710417212                        object->updateInformation(*update);
  • trunk/Cbc/src/CbcNode.cpp

    r2313 r2357  
    30803080                      saveOsiClpOptions=osiclp->specialOptions();
    30813081                      if (goToEndInStrongBranching==2 ||
    3082                           dynamicObject->numberTimesBranched()==0) {
     3082                          (dynamicObject &&
     3083                           dynamicObject->numberTimesBranched()==0)) {
     3084                        if (osiclp->getNumRows()<200||goToEndInStrongBranching==2) {
    30833085                        osiclp->setIntParam(OsiMaxNumIterationHotStart,
    30843086                                            10*(osiclp->getNumRows()+numberColumns));
    30853087                        osiclp->setSpecialOptions(saveOsiClpOptions & (~32));
     3088                        }
    30863089                      }
    30873090                    }
     
    32503253                        }
    32513254                    } else if (iStatus == 1) {
    3252                         objectiveChange = 1.0e100 ;
     3255                        choice.finishedDown = true ;
     3256                        objectiveChange = COIN_DBL_MAX ;
    32533257                        numberStrongInfeasible++;
    32543258                    } else {
     
    34863490                        }
    34873491                    } else if (iStatus == 1) {
    3488                         objectiveChange = 1.0e100 ;
     3492                        choice.finishedUp = true ;
     3493                        objectiveChange = COIN_DBL_MAX;
    34893494                        numberStrongInfeasible++;
    34903495                    } else {
  • trunk/Cbc/src/CbcSimpleIntegerDynamicPseudoCost.cpp

    r2232 r2357  
    619619    double sum;
    620620#ifndef INFEAS_MULTIPLIER
    621 #define INFEAS_MULTIPLIER 1.0
     621#define INFEAS_MULTIPLIER 1.5
    622622#endif
    623623    double number;
     
    744744        // was <= 10
    745745        //if (stateOfSearch<=1||model_->currentNode()->depth()<=-10 /* was ||maxValue>0.2*distanceToCutoff*/) {
    746         if (stateOfSearch <= 2) {
    747             // no branching solution
     746        if (stateOfSearch < 1) {
     747            // no solution
    748748#ifdef COIN_DEVELOP
    749749            where = 'i';
  • trunk/Cbc/src/CbcSolver.cpp

    r2345 r2357  
    13561356    CoinMessageHandler * generalMessageHandler = model_.messageHandler();
    13571357    generalMessageHandler->setPrefix(false);
     1358    int numberLotSizing=0;
     1359    typedef struct {double low;double high;int column;} lotStruct;   
     1360    lotStruct * lotsize=NULL;
    13581361#ifndef CBC_OTHER_SOLVER
    13591362    OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver());
     
    40164019                            }
    40174020                            if (type == CBC_PARAM_ACTION_BAB) {
     4021                                if (preProcess==0 && numberLotSizing) {
     4022                                  if (!babModel_->numberObjects()) {
     4023                                    /* model may not have created objects
     4024                                       If none then create
     4025                                    */
     4026                                    babModel_->findIntegers(true);
     4027                                  }
     4028                                  // Lotsizing
     4029                                  int numberColumns = babModel_->solver()->getNumCols();
     4030                                  CbcObject ** objects =
     4031                                    new CbcObject * [numberLotSizing];
     4032                                  double points[]={0.0,0.0,0.0,0.0};
     4033                                  for (int i = 0; i < numberLotSizing; i++) {
     4034                                    int iColumn = lotsize[i].column;
     4035                                    points[2]=lotsize[i].low;
     4036                                    points[3]=lotsize[i].high;
     4037                                    objects[i] = new
     4038                                      CbcLotsize (&model_,iColumn,2,
     4039                                                  points,true);
     4040                                  }
     4041                                  babModel_->addObjects(numberLotSizing,objects);
     4042                                  for (int i = 0; i < numberLotSizing; i++)
     4043                                    delete objects[i];
     4044                                  delete [] objects;
     4045                                }
    40184046                                double limit;
    40194047                                clpSolver->getDblParam(OsiDualObjectiveLimit, limit);
     
    41634191                                        model_.findIntegers(true);
    41644192                                    }
     4193                                    // Lotsizing
     4194                                    if (numberLotSizing) {
     4195                                      int numberColumns = saveSolver->getNumCols();
     4196                                      char * prohibited = new char[numberColumns];
     4197                                      memset(prohibited, 0, numberColumns);
     4198                                      for (int i = 0; i < numberLotSizing; i++) {
     4199                                        int iColumn = lotsize[i].column;
     4200                                        prohibited[iColumn] = 1;
     4201                                      }
     4202                                      process.passInProhibited(prohibited, numberColumns);
     4203                                      delete [] prohibited;
     4204                                    }
    41654205                                    if (model_.numberObjects()) {
    41664206                                        OsiObject ** oldObjects = babModel_->objects();
     
    43474387                                        }
    43484388                                    }
     4389                                    // do lotsizing
     4390                                    if (numberLotSizing) {
     4391                                      CbcObject ** objects =
     4392                                        new CbcObject * [numberLotSizing];
     4393                                      double points[]={0.0,0.0,0.0,0.0};
     4394                                      for (int i = 0; i < numberLotSizing; i++) {
     4395                                        int iColumn = lotsize[i].column;
     4396                                        points[2]=lotsize[i].low;
     4397                                        points[3]=lotsize[i].high;
     4398                                        objects[i] = new
     4399                                          CbcLotsize (babModel_,iColumn,2,
     4400                                                      points,true);
     4401                                      }
     4402                                      babModel_->addObjects(numberLotSizing,objects);
     4403                                      for (int i = 0; i < numberLotSizing; i++)
     4404                                        delete objects[i];
     4405                                      delete [] objects;
     4406                                    }
    43494407                                    // redo existing SOS
    43504408                                    if (osiclp->numberSOS()) {
     
    79508008                        if (canOpen) {
    79518009                            int status;
     8010                            numberLotSizing=0;
     8011                            delete [] lotsize;
    79528012#ifndef CBC_OTHER_SOLVER
    79538013                            ClpSimplex * lpSolver = clpSolver->getModelPtr();
     
    79838043                                lpSolver->createStatus();
    79848044                                // make sure integer
     8045                                // also deal with semi-continuous
    79858046                                int numberColumns = lpSolver->numberColumns();
    7986                                 for (int i = 0; i < numberColumns; i++) {
     8047                                int i;
     8048                                for (i = 0; i < numberColumns; i++) {
     8049                                    if (clpSolver->integerType(i)>2)
     8050                                      break;
    79878051                                    if (lpSolver->isInteger(i))
    79888052                                        clpSolver->setInteger(i);
     8053                                }
     8054                                if (i<numberColumns) {
     8055                                  // semi-continuous
     8056                                  clpSolver->setSpecialOptions(clpSolver->specialOptions()|8388608);
     8057                                  int iStart=i;
     8058                                  for (i=iStart; i < numberColumns; i++) {
     8059                                    if (clpSolver->integerType(i)>2)
     8060                                      numberLotSizing++;
     8061                                  }
     8062                                  lotsize = new lotStruct[numberLotSizing];
     8063                                  numberLotSizing=0;
     8064                                  const double * lower = clpSolver->getColLower();
     8065                                  const double * upper = clpSolver->getColUpper();
     8066                                  for (i=iStart; i < numberColumns; i++) {
     8067                                    if (clpSolver->integerType(i)>2) {
     8068                                      int iType=clpSolver->integerType(i)-3;
     8069                                      if (!iType)
     8070                                        clpSolver->setContinuous(i);
     8071                                      else
     8072                                        clpSolver->setInteger(i);
     8073                                      lotsize[numberLotSizing].column=i;
     8074                                      lotsize[numberLotSizing].high=upper[i];
     8075                                      if (lower[i]) {
     8076                                        lotsize[numberLotSizing++].low=lower[i];
     8077                                        clpSolver->setColLower(i,0.0);
     8078                                      } else {
     8079                                        lotsize[numberLotSizing++].low=1.0;
     8080                                      }
     8081                                    }
     8082                                  }
    79898083                                }
    79908084#else
     
    81688262#endif
    81698263                                numberSOS = clpSolver->numberSOS();
    8170                                 if (numberSOS)
     8264                                if (numberSOS || lotsize)
    81718265                                  preSolve = false;
    81728266#endif
     
    81948288
    81958289                                    }
    8196                                     model2->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1)&1));
     8290                                    // see if extension lp
     8291                                    bool writeLp=false;
     8292                                    {
     8293                                      int lengthName = strlen(fileName.c_str());
     8294                                      if (lengthName>3&&!strcmp(fileName.c_str()+lengthName-3,".lp"))
     8295                                        writeLp=true;
     8296                                    }
     8297                                    if (!writeLp) {
     8298                                      model2->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1)&1));
     8299                                    } else {
     8300                                      FILE *fp = fopen(fileName.c_str(), "w");
     8301                                      assert (fp);
     8302                                      OsiClpSolverInterface solver(model2);
     8303                                      solver.writeLp(fp,1.0e-12);
     8304                                    }
    81978305                                    if (deleteModel2)
    81988306                                        delete model2;
     
    82008308                                    printf("Saving model on %s\n",
    82018309                                           fileName.c_str());
    8202                                     if (numberSOS) {
     8310#ifdef COIN_HAS_LINK
     8311                                    OsiSolverLink * linkSolver = dynamic_cast< OsiSolverLink*> (clpSolver);
     8312                                    if (!linkSolver || !linkSolver->quadraticModel()) {
     8313#endif
    82038314                                        // Convert names
    82048315                                        int iRow;
     
    82288339                                          if (lengthName>3&&!strcmp(fileName.c_str()+lengthName-3,".lp"))
    82298340                                            writeLp=true;
     8341                                        }
     8342                                        if (lotsize) {
     8343                                          for (int i=0;i<numberLotSizing;i++) {
     8344                                            int iColumn=lotsize[i].column;
     8345                                            double low = lotsize[i].low;
     8346                                            if (low!=1.0)
     8347                                              clpSolver->setColLower(iColumn,low);
     8348                                            int type;
     8349                                            if (clpSolver->isInteger(iColumn))
     8350                                              type = 4;
     8351                                            else
     8352                                              type = 3;
     8353                                            clpSolver->setColumnType(iColumn,type);
     8354                                          }
    82308355                                        }
    82318356                                        if (!writeLp) {
     
    82488373                                            delete [] columnNames;
    82498374                                        }
     8375                                        if (lotsize) {
     8376                                          for (int i=0;i<numberLotSizing;i++) {
     8377                                            int iColumn=lotsize[i].column;
     8378                                            int itype=clpSolver->integerType(iColumn);
     8379                                            clpSolver->setColLower(iColumn,0.0);
     8380                                            if (itype==3)
     8381                                              clpSolver->setContinuous(iColumn);
     8382                                            else
     8383                                              clpSolver->setInteger(iColumn);
     8384                                          }
     8385                                        }
     8386#ifdef COIN_HAS_LINK
    82508387                                    } else {
    8251 #ifdef COIN_HAS_LINK
    8252                                         OsiSolverLink * linkSolver = dynamic_cast< OsiSolverLink*> (clpSolver);
    8253                                         if (!linkSolver || !linkSolver->quadraticModel())
    8254                                             model2->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1)&1));
    8255                                         else
    8256                                             linkSolver->quadraticModel()->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1)&1));
    8257 #endif
    8258                                     }
     8388                                      linkSolver->quadraticModel()->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1)&1));
     8389                                    }
     8390#endif
    82598391                                }
    82608392                                time2 = CoinCpuTime();
     
    1017310305    }
    1017410306#endif
     10307    delete [] lotsize;
    1017510308    delete [] statistics_number_cuts;
    1017610309    delete [] statistics_name_generators;
Note: See TracChangeset for help on using the changeset viewer.