Ignore:
Timestamp:
Nov 3, 2006 3:48:00 PM (13 years ago)
Author:
forrest
Message:

for nonlinear and start moving to OsiTree?
afor n

File:
1 edited

Legend:

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

    r473 r477  
    281281
    282282
    283 
     283static double trueIncrement=0.0;
    284284void
    285285CbcModel::analyzeObjective ()
     
    311311*/
    312312  double maximumCost = 0.0 ;
     313  trueIncrement=0.0;
    313314  bool possibleMultiple = true ;
    314315  int iColumn ;
     
    335336      while (10.0*multiplier*maximumCost < 1.0e8)
    336337        multiplier *= 10.0 ;
    337 
    338       for (iColumn = 0 ; iColumn < numberColumns ; iColumn++)
    339       { if (upper[iColumn] > lower[iColumn]+1.0e-8)
    340         { if (isInteger(iColumn)&&objective[iColumn])
    341           { double value = fabs(objective[iColumn])*multiplier ;
     338    int bigIntegers = 0; // Count of large costs which are integer
     339    for (iColumn = 0 ; iColumn < numberColumns ; iColumn++) {
     340      if (upper[iColumn] > lower[iColumn]+1.0e-8) {
     341        if (isInteger(iColumn)&&objective[iColumn]) {
     342          double value = fabs(objective[iColumn])*multiplier ;
     343          if (value <2.1e9) {
    342344            int nearest = (int) floor(value+0.5) ;
    343345            if (fabs(value-floor(value+0.5)) > 1.0e-8)
    344             { increment = 0 ;
     346              { increment = 0 ;
    345347              break ; }
    346348            else if (!increment)
    347             { increment = nearest ; }
     349              { increment = nearest ; }
    348350            else
    349             { increment = gcd(increment,nearest) ; } } } }
     351              { increment = gcd(increment,nearest) ; }
     352          } else {
     353            // large value - may still be multiple of 1.0
     354            value = fabs(objective[iColumn]);
     355            if (fabs(value-floor(value+0.5)) > 1.0e-8) {
     356              increment=0;
     357              break;
     358            } else {
     359              bigIntegers++;
     360            }
     361          }
     362        }
     363      }
     364    }
     365
    350366/*
    351367  If the increment beats the current value for objective change, install it.
     
    354370      { double value = increment ;
    355371        double cutoff = getDblParam(CbcModel::CbcCutoffIncrement) ;
     372        if (bigIntegers) {
     373          // allow for 1.0
     374          increment = gcd(increment,(int) multiplier);
     375          value = increment;
     376        }
    356377        value /= multiplier ;
     378        trueIncrement=CoinMax(cutoff,value);;
    357379        if (value*0.999 > cutoff)
    358380        { messageHandler()->message(CBC_INTEGERINCREMENT,
     
    748770      solver_->findIntegersAndSOS(false);
    749771      numberObjects_=solver_->numberObjects();
    750       object_ = new OsiObject * [numberObjects_];
    751       for (int iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    752         object_[iObject]=solver_->object(iObject)->clone();
    753       }
     772      object_ = solver_->objects();
     773      ownObjects_ = false;
    754774    }
    755775    branchingMethod_->chooseMethod()->setSolver(solver_);
     
    21962216    if (originalObject) {
    21972217      int iColumn;
     2218      assert (ownObjects_);
    21982219      for (iColumn=0;iColumn<numberObjects_;iColumn++)
    21992220        delete object_[iColumn];
     
    23532374  numberObjects_(0),
    23542375  object_(NULL),
     2376  ownObjects_(true),
    23552377  originalColumns_(NULL),
    23562378  howOftenGlobalScan_(1),
     
    24812503  numberObjects_(0),
    24822504  object_(NULL),
     2505  ownObjects_(true),
    24832506  originalColumns_(NULL),
    24842507  howOftenGlobalScan_(1),
     
    27672790  else
    27682791  { eventHandler_ = NULL ; }
    2769   numberObjects_=rhs.numberObjects_;
    2770   if (numberObjects_) {
    2771     object_ = new OsiObject * [numberObjects_];
    2772     int i;
    2773     for (i=0;i<numberObjects_;i++)
    2774       object_[i]=(rhs.object_[i])->clone();
     2792  ownObjects_ = rhs.ownObjects_;
     2793  if (ownObjects_) {
     2794    numberObjects_=rhs.numberObjects_;
     2795    if (numberObjects_) {
     2796      object_ = new OsiObject * [numberObjects_];
     2797      int i;
     2798      for (i=0;i<numberObjects_;i++)
     2799        object_[i]=(rhs.object_[i])->clone();
     2800    } else {
     2801      object_=NULL;
     2802    }
    27752803  } else {
     2804    // assume will be redone
     2805    numberObjects_=0;
    27762806    object_=NULL;
    27772807  }
     
    30473077    else
    30483078    { eventHandler_ = NULL ; }
    3049     for (i=0;i<numberObjects_;i++)
    3050       delete object_[i];
    3051     delete [] object_;
    3052     numberObjects_=rhs.numberObjects_;
    3053     if (numberObjects_) {
    3054       object_ = new OsiObject * [numberObjects_];
    3055       int i;
    3056       for (i=0;i<numberObjects_;i++)
    3057         object_[i]=(rhs.object_[i])->clone();
     3079    if (ownObjects_) {
     3080      for (i=0;i<numberObjects_;i++)
     3081        delete object_[i];
     3082      delete [] object_;
     3083      numberObjects_=rhs.numberObjects_;
     3084      if (numberObjects_) {
     3085        object_ = new OsiObject * [numberObjects_];
     3086        int i;
     3087        for (i=0;i<numberObjects_;i++)
     3088          object_[i]=(rhs.object_[i])->clone();
     3089      } else {
     3090        object_=NULL;
     3091    }
    30583092    } else {
     3093      // assume will be redone
     3094      numberObjects_=0;
    30593095      object_=NULL;
    30603096    }
     
    31853221  integerVariable_=NULL;
    31863222  int i;
    3187   for (i=0;i<numberObjects_;i++)
    3188     delete object_[i];
    3189   delete [] object_;
     3223  if (ownObjects_) {
     3224    for (i=0;i<numberObjects_;i++)
     3225      delete object_[i];
     3226    delete [] object_;
     3227  }
     3228  ownObjects_=true;
    31903229  object_=NULL;
    31913230  numberIntegers_=0;
     
    38593898    objectiveValue= node->objectiveValue();
    38603899  int returnCode = resolve(node ? node->nodeInfo() : NULL,1);
     3900#ifdef COIN_DEVELOP
     3901  //if (!solver_->getIterationCount()&&solver_->isProvenOptimal())
     3902  //printf("zero iterations on first solve of branch\n");
     3903#endif
    38613904  if (node&&!node->nodeInfo()->numberBranchesLeft())
    38623905    node->nodeInfo()->allBranchesGone(); // can clean up
     
    52135256    }
    52145257  }
    5215   if (!feasible&& continuousObjective_ <-1.0e30) {
     5258  if (false&&!feasible&& continuousObjective_ <-1.0e30) {
    52165259    // at root node - double double check
    52175260    bool saveTakeHint;
     
    52275270    }
    52285271  }
     5272  if (feasible&&!solverCharacteristics_->solutionAddsCuts()) {
     5273    //double increment = getDblParam(CbcModel::CbcCutoffIncrement) ;
     5274    double cutoff ;
     5275    solver_->getDblParam(OsiDualObjectiveLimit,cutoff) ;
     5276    double distance = fabs(cutoff-solver_->getObjValue());
     5277    if (distance<10.0*trueIncrement) {
     5278      double offset;
     5279      solver_->getDblParam(OsiObjOffset,offset);
     5280      double objFixedValue = -offset;
     5281      double objValue=0.0;
     5282      double direction = solver_->getObjSense();
     5283      const double * solution = solver_->getColSolution();
     5284      const double * objective = solver_->getObjCoefficients();
     5285      const double * columnLower = solver_->getColLower();
     5286      const double * columnUpper = solver_->getColUpper();
     5287      int numberColumns = solver_->getNumCols();
     5288      int increment = 0 ;
     5289      double multiplier = 1.0/trueIncrement;
     5290      int bigIntegers = 0; // Count of large costs which are integer
     5291      for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     5292        double value = solution[iColumn];
     5293        // make sure clean
     5294        value = CoinMin(value,columnUpper[iColumn]);
     5295        value = CoinMax(value,columnLower[iColumn]);
     5296        double cost = direction * objective[iColumn];
     5297        if (cost) {
     5298          if (columnLower[iColumn]<columnUpper[iColumn]) {
     5299            objValue += value*cost;
     5300            value = fabs(cost)*multiplier ;
     5301            if (value <2.1e9) {
     5302              int nearest = (int) floor(value+0.5) ;
     5303              assert (fabs(value-floor(value+0.5)) < 1.0e-8);
     5304              if (!increment)
     5305                increment = nearest ;
     5306              else
     5307                increment = gcd(increment,nearest) ;
     5308            } else {
     5309              // large value - may still be multiple of 1.0
     5310              value = fabs(objective[iColumn]);
     5311              assert(fabs(value-floor(value+0.5)) < 1.0e-8);
     5312              bigIntegers++;
     5313            }
     5314          } else {
     5315            // fixed
     5316            objFixedValue += value*cost;
     5317          }
     5318        }
     5319      }
     5320      if (increment) {
     5321        double value = increment ;
     5322        value /= multiplier ;
     5323        if (value>trueIncrement) {
     5324          double x = objValue/value;
     5325          x = ceil(x-1.0e-5);
     5326          x *= value;
     5327          //printf("fixed %g, variable %g -> %g, sum %g - cutoff %g\n",
     5328          // objFixedValue,objValue,x,x+objFixedValue,cutoff);
     5329          x += objFixedValue;
     5330          if (x>cutoff + 1.0e-5*fabs(cutoff)+1.0e-5) {
     5331            //printf("Node cutoff\n");
     5332            feasible=false;
     5333          }
     5334        } else {
     5335          value = trueIncrement;
     5336          double x = objValue/value;
     5337          x = ceil(x-1.0e-5);
     5338          x *= value;
     5339          x += objFixedValue;
     5340          if (x>cutoff + 1.0e-5*fabs(cutoff)+1.0e-5) {
     5341            //printf("Node cutoff\n");
     5342            feasible=false;
     5343          }
     5344        }
     5345      }
     5346    }
     5347  }
     5348
    52295349  setPointers(solver_);
    52305350  int returnStatus = feasible ? 1 : 0;
     
    55045624    delete [] element;
    55055625    newModel->addObjects(numberCliques,object);
     5626    assert (ownObjects_);
    55065627    for (;i<numberCliques;i++)
    55075628      delete object[i];
     
    55105631    return newModel;
    55115632  } else {
     5633    assert (ownObjects_);
    55125634    if (numberCliques>0) {
    55135635      addObjects(numberCliques,object);
     
    56515773CbcModel::deleteObjects(bool getIntegers)
    56525774{
    5653   int i;
    5654   for (i=0;i<numberObjects_;i++)
    5655     delete object_[i];
    5656   delete [] object_;
     5775  if (ownObjects_) {
     5776    int i;
     5777    for (i=0;i<numberObjects_;i++)
     5778      delete object_[i];
     5779    delete [] object_;
     5780  }
    56575781  object_ = NULL;
    56585782  numberObjects_=0;
    5659   if (getIntegers)
     5783  if (getIntegers&&ownObjects_)
    56605784    findIntegers(true);
    56615785}
     
    59436067  }
    59446068  delete [] mark;
     6069  assert (ownObjects_);
    59456070  delete [] object_;
    59466071  object_ = temp;
     
    60566181  }
    60576182  delete [] mark;
     6183  assert (ownObjects_);
    60586184  delete [] object_;
    60596185  object_ = temp;
     
    70977223                                   bool weak)
    70987224{
     7225  printf("DEPRECATED\n");
    70997226  status_ = 0;
    71007227  // solve LP
     
    72227349              double value = fabs(objective[iColumn])*multiplier;
    72237350              int nearest = (int) floor(value+0.5);
    7224               if (fabs(value-floor(value+0.5))>1.0e-8) {
     7351              if (fabs(value-floor(value+0.5))>1.0e-8||value>2.1e9) {
    72257352                increment=0;
    72267353                break; // no good
Note: See TracChangeset for help on using the changeset viewer.