- Timestamp:
- Sep 7, 2007 10:18:19 AM (13 years ago)
- Location:
- trunk/Cbc/src
- Files:
-
- 1 added
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Cbc/src/CbcModel.cpp
r777 r779 1635 1635 if ((numberNodes_%printFrequency_) == 0) { 1636 1636 lockThread(); 1637 int j ;1638 1637 int nNodes = tree_->size() ; 1639 1638 … … 2762 2761 presolve_(0), 2763 2762 numberStrong_(5), 2764 numberBeforeTrust_( 0),2763 numberBeforeTrust_(10), 2765 2764 numberPenalties_(20), 2766 2765 penaltyScaleFactor_(3.0), … … 2900 2899 presolve_(0), 2901 2900 numberStrong_(5), 2902 numberBeforeTrust_( 0),2901 numberBeforeTrust_(10), 2903 2902 numberPenalties_(20), 2904 2903 penaltyScaleFactor_(3.0), -
trunk/Cbc/src/CbcModel.hpp
r765 r779 2093 2093 // When we want to load up CbcModel with options first 2094 2094 void CbcMain0 (CbcModel & babSolver); 2095 int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, 2096 int call_CbcClpUnitTest_on_777 = 0); 2095 int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver); 2097 2096 // two ways of calling 2098 2097 int callCbc(const char * input2, CbcModel & babSolver); … … 2104 2103 int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 2105 2104 int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 2106 int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom) , int call_CbcClpUnitTest_on_777 = 0);2105 int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 2107 2106 #endif -
trunk/Cbc/src/CbcSolver.cpp
r777 r779 141 141 142 142 #include "OsiClpSolverInterface.hpp" 143 //#define NEW_STYLE_SOLVER 144 #ifdef NEW_STYLE_SOLVER 145 #include "CbcSolver.hpp" 146 CbcSolver::CbcSolver() 147 : babModel_(NULL), 148 userFunction_(NULL), 149 numberUserFunctions_(0), 150 startTime_(CoinCpuTime()), 151 parameters_(NULL), 152 numberParameters_(0), 153 doMiplib_(false), 154 noPrinting_(false) 155 { 156 callBack_ = new CbcStopNow(); 157 fillParameters(); 158 } 159 CbcSolver::CbcSolver(const OsiClpSolverInterface & solver) 160 : babModel_(NULL), 161 userFunction_(NULL), 162 numberUserFunctions_(0), 163 startTime_(CoinCpuTime()), 164 parameters_(NULL), 165 numberParameters_(0), 166 doMiplib_(false), 167 noPrinting_(false) 168 { 169 callBack_ = new CbcStopNow(); 170 model_ = CbcModel(solver); 171 fillParameters(); 172 } 173 CbcSolver::CbcSolver(const CbcModel & solver) 174 : babModel_(NULL), 175 userFunction_(NULL), 176 numberUserFunctions_(0), 177 startTime_(CoinCpuTime()), 178 parameters_(NULL), 179 numberParameters_(0), 180 doMiplib_(false), 181 noPrinting_(false) 182 { 183 callBack_ = new CbcStopNow(); 184 model_ = solver; 185 fillParameters(); 186 } 187 CbcSolver::~CbcSolver() 188 { 189 int i; 190 for (i=0;i<numberUserFunctions_;i++) 191 delete userFunction_[i]; 192 delete [] userFunction_; 193 delete babModel_; 194 delete [] parameters_; 195 delete callBack_; 196 } 197 // Copy constructor 198 CbcSolver::CbcSolver ( const CbcSolver & rhs) 199 : model_(rhs.model_), 200 babModel_(NULL), 201 userFunction_(NULL), 202 numberUserFunctions_(rhs.numberUserFunctions_), 203 startTime_(CoinCpuTime()), 204 parameters_(NULL), 205 numberParameters_(rhs.numberParameters_), 206 doMiplib_(rhs.doMiplib_), 207 noPrinting_(rhs.noPrinting_) 208 { 209 fillParameters(); 210 if (rhs.babModel_) 211 babModel_ = new CbcModel(*rhs.babModel_); 212 userFunction_ = new CbcUser * [numberUserFunctions_]; 213 int i; 214 for (i=0;i<numberUserFunctions_;i++) 215 userFunction_[i] = rhs.userFunction_[i]->clone(); 216 for (i=0;i<numberParameters_;i++) 217 parameters_[i]=rhs.parameters_[i]; 218 callBack_ = rhs.callBack_->clone(); 219 } 220 // Assignment operator 221 CbcSolver & 222 CbcSolver::operator=(const CbcSolver & rhs) 223 { 224 if (this != &rhs) { 225 int i; 226 for (i=0;i<numberUserFunctions_;i++) 227 delete userFunction_[i]; 228 delete [] userFunction_; 229 delete babModel_; 230 delete [] parameters_; 231 delete callBack_; 232 numberUserFunctions_ = rhs.numberUserFunctions_; 233 startTime_ = rhs.startTime_; 234 numberParameters_= rhs.numberParameters_; 235 for (i=0;i<numberParameters_;i++) 236 parameters_[i]=rhs.parameters_[i]; 237 noPrinting_ = rhs.noPrinting_; 238 doMiplib_ = rhs.doMiplib_; 239 model_ = rhs.model_; 240 if (rhs.babModel_) 241 babModel_ = new CbcModel(*rhs.babModel_); 242 else 243 babModel_ = NULL; 244 userFunction_ = new CbcUser * [numberUserFunctions_]; 245 for (i=0;i<numberUserFunctions_;i++) 246 userFunction_[i] = rhs.userFunction_[i]->clone(); 247 callBack_ = rhs.callBack_->clone(); 248 } 249 return *this; 250 } 251 // Get int value 252 int CbcSolver::intValue(CbcOrClpParameterType type) const 253 { 254 return parameters_[whichParam(type,numberParameters_,parameters_)].intValue(); 255 } 256 // Set int value 257 void CbcSolver::setIntValue(CbcOrClpParameterType type,int value) 258 { 259 parameters_[whichParam(type,numberParameters_,parameters_)].setIntValue(value); 260 } 261 // Get double value 262 double CbcSolver::doubleValue(CbcOrClpParameterType type) const 263 { 264 return parameters_[whichParam(type,numberParameters_,parameters_)].doubleValue(); 265 } 266 // Set double value 267 void CbcSolver::setDoubleValue(CbcOrClpParameterType type,double value) 268 { 269 parameters_[whichParam(type,numberParameters_,parameters_)].setDoubleValue(value); 270 } 271 // User function (NULL if no match) 272 CbcUser * CbcSolver::userFunction(const char * name) const 273 { 274 int i; 275 for (i=0;i<numberUserFunctions_;i++) { 276 if (!strcmp(name,userFunction_[i]->name().c_str())) 277 break; 278 } 279 if (i<numberUserFunctions_) 280 return userFunction_[i]; 281 else 282 return NULL; 283 } 284 void CbcSolver::fillParameters() 285 { 286 int maxParam = 200; 287 CbcOrClpParam * parameters = new CbcOrClpParam [maxParam]; 288 numberParameters_=0 ; 289 establishParams(numberParameters_,parameters) ; 290 assert (numberParameters_<=maxParam); 291 parameters_ = new CbcOrClpParam [numberParameters_]; 292 int i; 293 for (i=0;i<numberParameters_;i++) 294 parameters_[i]=parameters[i]; 295 delete [] parameters; 296 const char dirsep = CoinFindDirSeparator(); 297 std::string directory; 298 std::string dirSample; 299 std::string dirNetlib; 300 std::string dirMiplib; 301 if (dirsep == '/') { 302 directory = "./"; 303 dirSample = "../../Data/Sample/"; 304 dirNetlib = "../../Data/Netlib/"; 305 dirMiplib = "../../Data/miplib3/"; 306 } else { 307 directory = ".\\"; 308 dirSample = "..\\..\\Data\\Sample\\"; 309 dirNetlib = "..\\..\\Data\\Netlib\\"; 310 dirMiplib = "..\\..\\Data\\miplib3\\"; 311 } 312 std::string defaultDirectory = directory; 313 std::string importFile =""; 314 std::string exportFile ="default.mps"; 315 std::string importBasisFile =""; 316 std::string importPriorityFile =""; 317 std::string debugFile=""; 318 std::string printMask=""; 319 std::string exportBasisFile ="default.bas"; 320 std::string saveFile ="default.prob"; 321 std::string restoreFile ="default.prob"; 322 std::string solutionFile ="stdout"; 323 std::string solutionSaveFile ="solution.file"; 324 int doIdiot=-1; 325 int outputFormat=2; 326 int substitution=3; 327 int dualize=0; 328 int preSolve=5; 329 int doSprint=-1; 330 int testOsiParameters=-1; 331 int createSolver=0; 332 ClpSimplex * lpSolver; 333 OsiClpSolverInterface * clpSolver; 334 if (model_.solver()) { 335 clpSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver()); 336 assert (clpSolver); 337 lpSolver = clpSolver->getModelPtr(); 338 assert (lpSolver); 339 } else { 340 lpSolver = new ClpSimplex(); 341 clpSolver = new OsiClpSolverInterface(lpSolver,true); 342 createSolver =1 ; 343 } 344 parameters_[whichParam(BASISIN,numberParameters_,parameters_)].setStringValue(importBasisFile); 345 parameters_[whichParam(PRIORITYIN,numberParameters_,parameters_)].setStringValue(importPriorityFile); 346 parameters_[whichParam(BASISOUT,numberParameters_,parameters_)].setStringValue(exportBasisFile); 347 parameters_[whichParam(DEBUG,numberParameters_,parameters_)].setStringValue(debugFile); 348 parameters_[whichParam(PRINTMASK,numberParameters_,parameters_)].setStringValue(printMask); 349 parameters_[whichParam(DIRECTORY,numberParameters_,parameters_)].setStringValue(directory); 350 parameters_[whichParam(DIRSAMPLE,numberParameters_,parameters_)].setStringValue(dirSample); 351 parameters_[whichParam(DIRNETLIB,numberParameters_,parameters_)].setStringValue(dirNetlib); 352 parameters_[whichParam(DIRMIPLIB,numberParameters_,parameters_)].setStringValue(dirMiplib); 353 parameters_[whichParam(DUALBOUND,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualBound()); 354 parameters_[whichParam(DUALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualTolerance()); 355 parameters_[whichParam(EXPORT,numberParameters_,parameters_)].setStringValue(exportFile); 356 parameters_[whichParam(IDIOT,numberParameters_,parameters_)].setIntValue(doIdiot); 357 parameters_[whichParam(IMPORT,numberParameters_,parameters_)].setStringValue(importFile); 358 parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].setDoubleValue(1.0e-8); 359 int iParam = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_); 360 int value=1; 361 clpSolver->messageHandler()->setLogLevel(1) ; 362 lpSolver->setLogLevel(1); 363 parameters_[iParam].setIntValue(value); 364 iParam = whichParam(LOGLEVEL,numberParameters_,parameters_); 365 model_.messageHandler()->setLogLevel(value); 366 parameters_[iParam].setIntValue(value); 367 parameters_[whichParam(MAXFACTOR,numberParameters_,parameters_)].setIntValue(lpSolver->factorizationFrequency()); 368 parameters_[whichParam(MAXITERATION,numberParameters_,parameters_)].setIntValue(lpSolver->maximumIterations()); 369 parameters_[whichParam(OUTPUTFORMAT,numberParameters_,parameters_)].setIntValue(outputFormat); 370 parameters_[whichParam(PRESOLVEPASS,numberParameters_,parameters_)].setIntValue(preSolve); 371 parameters_[whichParam(PERTVALUE,numberParameters_,parameters_)].setIntValue(lpSolver->perturbation()); 372 parameters_[whichParam(PRIMALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->primalTolerance()); 373 parameters_[whichParam(PRIMALWEIGHT,numberParameters_,parameters_)].setDoubleValue(lpSolver->infeasibilityCost()); 374 parameters_[whichParam(RESTORE,numberParameters_,parameters_)].setStringValue(restoreFile); 375 parameters_[whichParam(SAVE,numberParameters_,parameters_)].setStringValue(saveFile); 376 //parameters_[whichParam(TIMELIMIT,numberParameters_,parameters_)].setDoubleValue(1.0e8); 377 parameters_[whichParam(TIMELIMIT_BAB,numberParameters_,parameters_)].setDoubleValue(1.0e8); 378 parameters_[whichParam(SOLUTION,numberParameters_,parameters_)].setStringValue(solutionFile); 379 parameters_[whichParam(SAVESOL,numberParameters_,parameters_)].setStringValue(solutionSaveFile); 380 parameters_[whichParam(SPRINT,numberParameters_,parameters_)].setIntValue(doSprint); 381 parameters_[whichParam(SUBSTITUTION,numberParameters_,parameters_)].setIntValue(substitution); 382 parameters_[whichParam(DUALIZE,numberParameters_,parameters_)].setIntValue(dualize); 383 parameters_[whichParam(NUMBERBEFORE,numberParameters_,parameters_)].setIntValue(model_.numberBeforeTrust()); 384 parameters_[whichParam(MAXNODES,numberParameters_,parameters_)].setIntValue(model_.getMaximumNodes()); 385 parameters_[whichParam(STRONGBRANCHING,numberParameters_,parameters_)].setIntValue(model_.numberStrong()); 386 parameters_[whichParam(INFEASIBILITYWEIGHT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight)); 387 parameters_[whichParam(INTEGERTOLERANCE,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance)); 388 parameters_[whichParam(INCREMENT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement)); 389 parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(testOsiParameters); 390 parameters_[whichParam(FPUMPTUNE,numberParameters_,parameters_)].setIntValue(1003); 391 #ifdef CBC_THREAD 392 parameters_[whichParam(THREADS,numberParameters_,parameters_)].setIntValue(0); 393 #endif 394 // Set up likely cut generators and defaults 395 parameters_[whichParam(PREPROCESS,numberParameters_,parameters_)].setCurrentOption("on"); 396 parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].setIntValue(128|64|1); 397 parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].setIntValue(1); 398 parameters_[whichParam(CUTPASSINTREE,numberParameters_,parameters_)].setIntValue(1); 399 parameters_[whichParam(MOREMIPOPTIONS,numberParameters_,parameters_)].setIntValue(-1); 400 parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].setIntValue(100); 401 parameters_[whichParam(CUTSSTRATEGY,numberParameters_,parameters_)].setCurrentOption("on"); 402 parameters_[whichParam(HEURISTICSTRATEGY,numberParameters_,parameters_)].setCurrentOption("on"); 403 parameters_[whichParam(NODESTRATEGY,numberParameters_,parameters_)].setCurrentOption("fewest"); 404 parameters_[whichParam(GOMORYCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove"); 405 parameters_[whichParam(PROBINGCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove"); 406 parameters_[whichParam(KNAPSACKCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove"); 407 parameters_[whichParam(REDSPLITCUTS,numberParameters_,parameters_)].setCurrentOption("off"); 408 parameters_[whichParam(CLIQUECUTS,numberParameters_,parameters_)].setCurrentOption("ifmove"); 409 parameters_[whichParam(MIXEDCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove"); 410 parameters_[whichParam(FLOWCUTS,numberParameters_,parameters_)].setCurrentOption("ifmove"); 411 parameters_[whichParam(TWOMIRCUTS,numberParameters_,parameters_)].setCurrentOption("root"); 412 parameters_[whichParam(LANDPCUTS,numberParameters_,parameters_)].setCurrentOption("off"); 413 parameters_[whichParam(RESIDCUTS,numberParameters_,parameters_)].setCurrentOption("off"); 414 parameters_[whichParam(ROUNDING,numberParameters_,parameters_)].setCurrentOption("on"); 415 parameters_[whichParam(FPUMP,numberParameters_,parameters_)].setCurrentOption("on"); 416 parameters_[whichParam(GREEDY,numberParameters_,parameters_)].setCurrentOption("on"); 417 parameters_[whichParam(COMBINE,numberParameters_,parameters_)].setCurrentOption("on"); 418 parameters_[whichParam(RINS,numberParameters_,parameters_)].setCurrentOption("off"); 419 parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].setCurrentOption("off"); 420 parameters_[whichParam(COSTSTRATEGY,numberParameters_,parameters_)].setCurrentOption("off"); 421 if (createSolver) 422 delete clpSolver; 423 } 424 void CbcSolver::fillValuesInSolver() 425 { 426 OsiSolverInterface * solver = model_.solver(); 427 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver); 428 assert (clpSolver); 429 noPrinting_ = (clpSolver->getModelPtr()->logLevel()==0); 430 CoinMessageHandler * generalMessageHandler = clpSolver->messageHandler(); 431 generalMessageHandler->setPrefix(true); 432 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 433 lpSolver->setPerturbation(50); 434 lpSolver->messageHandler()->setPrefix(false); 435 parameters_[whichParam(DUALBOUND,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualBound()); 436 parameters_[whichParam(DUALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->dualTolerance()); 437 int iParam = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_); 438 int value=parameters_[iParam].intValue(); 439 clpSolver->messageHandler()->setLogLevel(value) ; 440 lpSolver->setLogLevel(value); 441 iParam = whichParam(LOGLEVEL,numberParameters_,parameters_); 442 value=parameters_[iParam].intValue(); 443 model_.messageHandler()->setLogLevel(value); 444 parameters_[whichParam(LOGLEVEL,numberParameters_,parameters_)].setIntValue(model_.logLevel()); 445 parameters_[whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_)].setIntValue(lpSolver->logLevel()); 446 parameters_[whichParam(MAXFACTOR,numberParameters_,parameters_)].setIntValue(lpSolver->factorizationFrequency()); 447 parameters_[whichParam(MAXITERATION,numberParameters_,parameters_)].setIntValue(lpSolver->maximumIterations()); 448 parameters_[whichParam(PERTVALUE,numberParameters_,parameters_)].setIntValue(lpSolver->perturbation()); 449 parameters_[whichParam(PRIMALTOLERANCE,numberParameters_,parameters_)].setDoubleValue(lpSolver->primalTolerance()); 450 parameters_[whichParam(PRIMALWEIGHT,numberParameters_,parameters_)].setDoubleValue(lpSolver->infeasibilityCost()); 451 parameters_[whichParam(NUMBERBEFORE,numberParameters_,parameters_)].setIntValue(model_.numberBeforeTrust()); 452 parameters_[whichParam(MAXNODES,numberParameters_,parameters_)].setIntValue(model_.getMaximumNodes()); 453 parameters_[whichParam(STRONGBRANCHING,numberParameters_,parameters_)].setIntValue(model_.numberStrong()); 454 parameters_[whichParam(INFEASIBILITYWEIGHT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcInfeasibilityWeight)); 455 parameters_[whichParam(INTEGERTOLERANCE,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcIntegerTolerance)); 456 parameters_[whichParam(INCREMENT,numberParameters_,parameters_)].setDoubleValue(model_.getDblParam(CbcModel::CbcCutoffIncrement)); 457 } 458 // User stuff (base class) 459 CbcUser::CbcUser() 460 : coinModel_(NULL), 461 userName_("null") 462 { 463 } 464 CbcUser::~CbcUser() 465 { 466 delete coinModel_; 467 } 468 // Copy constructor 469 CbcUser::CbcUser ( const CbcUser & rhs) 470 { 471 if (rhs.coinModel_) 472 coinModel_ = new CoinModel(*rhs.coinModel_); 473 else 474 coinModel_ = NULL; 475 userName_ = rhs.userName_; 476 } 477 // Assignment operator 478 CbcUser & 479 CbcUser::operator=(const CbcUser & rhs) 480 { 481 if (this != &rhs) { 482 if (rhs.coinModel_) 483 coinModel_ = new CoinModel(*rhs.coinModel_); 484 else 485 coinModel_ = NULL; 486 userName_ = rhs.userName_; 487 } 488 return *this; 489 } 490 /* Updates model_ from babModel_ according to returnMode 491 returnMode - 492 0 model and solver untouched - babModel updated 493 1 model updated - just with solution basis etc 494 2 model updated i.e. as babModel (babModel NULL) 495 */ 496 void 497 CbcSolver::updateModel(ClpSimplex * model2, int returnMode) 498 { 499 if (!returnMode) 500 return; 501 if (returnMode==2&&babModel_) 502 model_ = *babModel_; 503 if (model2) { 504 // Only continuous valid 505 // update with basis etc 506 // map states 507 /* clp status 508 -1 - unknown e.g. before solve or if postSolve says not optimal 509 0 - optimal 510 1 - primal infeasible 511 2 - dual infeasible 512 3 - stopped on iterations or time 513 4 - stopped due to errors 514 5 - stopped by event handler (virtual int ClpEventHandler::event()) */ 515 /* cbc status 516 -1 before branchAndBound 517 0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found 518 (or check value of best solution) 519 1 stopped - on maxnodes, maxsols, maxtime 520 2 difficulties so run was abandoned 521 (5 event user programmed event occurred) */ 522 /* clp secondary status of problem - may get extended 523 0 - none 524 1 - primal infeasible because dual limit reached OR probably primal 525 infeasible but can't prove it (main status 4) 526 2 - scaled problem optimal - unscaled problem has primal infeasibilities 527 3 - scaled problem optimal - unscaled problem has dual infeasibilities 528 4 - scaled problem optimal - unscaled problem has primal and dual infeasibilities 529 5 - giving up in primal with flagged variables 530 6 - failed due to empty problem check 531 7 - postSolve says not optimal 532 8 - failed due to bad element check 533 9 - status was 3 and stopped on time 534 100 up - translation of enum from ClpEventHandler 535 */ 536 /* cbc secondary status of problem 537 -1 unset (status_ will also be -1) 538 0 search completed with solution 539 1 linear relaxation not feasible (or worse than cutoff) 540 2 stopped on gap 541 3 stopped on nodes 542 4 stopped on time 543 5 stopped on user event 544 6 stopped on solutions 545 7 linear relaxation unbounded 546 */ 547 int iStatus = model2->status(); 548 int iStatus2 = model2->secondaryStatus(); 549 if (iStatus==0) { 550 iStatus2=0; 551 } else if (iStatus==1) { 552 iStatus=0; 553 iStatus2=1; // say infeasible 554 } else if (iStatus==2) { 555 iStatus=0; 556 iStatus2=7; // say unbounded 557 } else if (iStatus==3) { 558 iStatus=1; 559 if (iStatus2==9) 560 iStatus2=4; 561 else 562 iStatus2=3; // Use nodes - as closer than solutions 563 } else if (iStatus==4) { 564 iStatus=2; // difficulties 565 iStatus2=0; 566 } 567 model_.setProblemStatus(iStatus); 568 model_.setSecondaryStatus(iStatus2); 569 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver()); 570 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 571 if (model2!=lpSolver) { 572 lpSolver->moveInfo(*model2); 573 } 574 clpSolver->setWarmStart(NULL); // synchronize bases 575 } else if (returnMode==1) { 576 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver()); 577 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 578 if (babModel_) { 579 model_.moveInfo(*babModel_); 580 int numberColumns = babModel_->getNumCols(); 581 if (babModel_->bestSolution()) 582 model_.setBestSolution(babModel_->bestSolution(),numberColumns,babModel_->getObjValue()); 583 OsiClpSolverInterface * clpSolver1 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 584 ClpSimplex * lpSolver1 = clpSolver1->getModelPtr(); 585 if (lpSolver1!=lpSolver) { 586 lpSolver->moveInfo(*lpSolver1); 587 } 588 } 589 clpSolver->setWarmStart(NULL); // synchronize bases 590 } 591 if (returnMode==2) { 592 delete babModel_; 593 babModel_=NULL; 594 } 595 } 596 // Clone 597 CbcUser * 598 CbcUser::clone() const 599 { 600 return new CbcUser(*this); 601 } 602 // Stop now stuff (base class) 603 CbcStopNow::CbcStopNow() 604 { 605 } 606 CbcStopNow::~CbcStopNow() 607 { 608 } 609 // Copy constructor 610 CbcStopNow::CbcStopNow ( const CbcStopNow & rhs) 611 { 612 } 613 // Assignment operator 614 CbcStopNow & 615 CbcStopNow::operator=(const CbcStopNow & rhs) 616 { 617 if (this != &rhs) { 618 } 619 return *this; 620 } 621 // Clone 622 CbcStopNow * 623 CbcStopNow::clone() const 624 { 625 return new CbcStopNow(*this); 626 } 627 #endif 143 628 #ifdef COIN_HAS_ASL 144 629 #include "Cbc_ampl.h" … … 184 669 } 185 670 #endif 186 671 #if 0 672 /* Updates model_ from babModel_ according to returnMode 673 returnMode - 674 0 model and solver untouched 675 1 model updated - just with solution basis etc 676 */ 677 static void updateModel(CbcModel & model_,int returnMode) 678 { 679 if (!returnMode) 680 return; 681 assert (returnMode==1); 682 } 683 #endif 187 684 int CbcOrClpRead_mode=1; 188 685 FILE * CbcOrClpReadCommand=stdin; 189 686 static bool noPrinting=false; 687 #ifdef NEW_STYLE_SOLVER 688 int * CbcSolver::analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment, 689 bool changeInt, CoinMessageHandler * generalMessageHandler) 690 #else 190 691 static int * analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment, 191 692 bool changeInt, CoinMessageHandler * generalMessageHandler) 693 #endif 192 694 { 695 #ifndef NEW_STYLE_SOLVER 696 bool noPrinting_ = noPrinting; 697 #endif 193 698 OsiSolverInterface * solver = solverMod->clone(); 194 699 char generalPrint[200]; … … 433 938 delete [] changeRhs; 434 939 delete [] ignore; 435 //if (numberInteger&&!noPrinting )940 //if (numberInteger&&!noPrinting_) 436 941 //printf("%d integer variables",numberInteger); 437 942 if (changeInt) { 438 //if (!noPrinting ) {943 //if (!noPrinting_) { 439 944 //if (numberChanged) 440 945 // printf(" and %d variables made integer\n",numberChanged); … … 457 962 } 458 963 } else { 459 //if (!noPrinting ) {964 //if (!noPrinting_) { 460 965 //if (numberChanged) 461 966 // printf(" and %d variables could be made integer\n",numberChanged); … … 467 972 CbcModel model(*solver); 468 973 model.passInMessageHandler(generalMessageHandler); 469 if (noPrinting )974 if (noPrinting_) 470 975 model.setLogLevel(0); 471 976 model.analyzeObjective(); … … 473 978 double increment2=model.getCutoffIncrement(); 474 979 if (increment2>increment&&increment2>0.0) { 475 if (!noPrinting ) {980 if (!noPrinting_) { 476 981 sprintf(generalPrint,"Cutoff increment increased from %g to %g",increment,increment2); 477 982 CoinMessages generalMessages = solverMod->getModelPtr()->messages(); … … 1267 1772 if (fixColumn[iColumn+1]-fixColumn[iColumn]==0&&doAction<10) 1268 1773 continue; 1269 double value = fullSolution[iColumn];1774 //double value = fullSolution[iColumn]; 1270 1775 double djValue = dj[iColumn]; 1271 1776 if (state[iColumn]==1) { … … 2156 2661 #endif 2157 2662 } 2663 #ifndef NEW_STYLE_SOLVER 2158 2664 int callCbc1(const char * input2, CbcModel & model, int callBack(CbcModel * currentSolver, int whereFrom)) 2159 2665 { … … 2265 2771 } 2266 2772 int CbcMain1 (int argc, const char *argv[], 2267 CbcModel & model , int call_CbcClpUnitTest_on_777)2773 CbcModel & model) 2268 2774 { 2269 return CbcMain1(argc,argv,model,dummyCallBack , call_CbcClpUnitTest_on_777);2775 return CbcMain1(argc,argv,model,dummyCallBack); 2270 2776 } 2271 2777 int callCbc1(const std::string input2, CbcModel & babSolver, int callBack(CbcModel * currentSolver, int whereFrom)) … … 2415 2921 parameters[whichParam(COSTSTRATEGY,numberParameters,parameters)].setCurrentOption("off"); 2416 2922 } 2417 2923 #endif 2418 2924 /* 1 - add heuristics to model 2419 2925 2 - do heuristics (and set cutoff and best solution) 2420 2926 3 - for miplib test so skip some 2421 2927 */ 2928 #ifndef NEW_STYLE_SOLVER 2422 2929 static int doHeuristics(CbcModel * model,int type) 2930 #else 2931 int 2932 CbcSolver::doHeuristics(CbcModel * model,int type) 2933 #endif 2423 2934 { 2935 #ifndef NEW_STYLE_SOLVER 2936 CbcOrClpParam * parameters_ = parameters; 2937 int numberParameters_ = numberParameters; 2938 #endif 2424 2939 bool anyToDo=false; 2425 int logLevel = parameters [whichParam(LOGLEVEL,numberParameters,parameters)].intValue();2426 int useFpump = parameters [whichParam(FPUMP,numberParameters,parameters)].currentOptionAsInteger();2427 int useRounding = parameters [whichParam(ROUNDING,numberParameters,parameters)].currentOptionAsInteger();2428 int useGreedy = parameters [whichParam(GREEDY,numberParameters,parameters)].currentOptionAsInteger();2429 int useCombine = parameters [whichParam(COMBINE,numberParameters,parameters)].currentOptionAsInteger();2430 int useRINS = parameters [whichParam(RINS,numberParameters,parameters)].currentOptionAsInteger();2940 int logLevel = parameters_[whichParam(LOGLEVEL,numberParameters_,parameters_)].intValue(); 2941 int useFpump = parameters_[whichParam(FPUMP,numberParameters_,parameters_)].currentOptionAsInteger(); 2942 int useRounding = parameters_[whichParam(ROUNDING,numberParameters_,parameters_)].currentOptionAsInteger(); 2943 int useGreedy = parameters_[whichParam(GREEDY,numberParameters_,parameters_)].currentOptionAsInteger(); 2944 int useCombine = parameters_[whichParam(COMBINE,numberParameters_,parameters_)].currentOptionAsInteger(); 2945 int useRINS = parameters_[whichParam(RINS,numberParameters_,parameters_)].currentOptionAsInteger(); 2431 2946 // FPump done first as it only works if no solution 2432 2947 int kType = (type<3) ? type : 1; … … 2435 2950 CbcHeuristicFPump heuristic4(*model); 2436 2951 heuristic4.setFractionSmall(0.5); 2437 double dextra3 = parameters [whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();2952 double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue(); 2438 2953 if (dextra3) 2439 2954 heuristic4.setFractionSmall(dextra3); 2440 heuristic4.setMaximumPasses(parameters [whichParam(FPUMPITS,numberParameters,parameters)].intValue());2441 int pumpTune=parameters [whichParam(FPUMPTUNE,numberParameters,parameters)].intValue();2955 heuristic4.setMaximumPasses(parameters_[whichParam(FPUMPITS,numberParameters_,parameters_)].intValue()); 2956 int pumpTune=parameters_[whichParam(FPUMPTUNE,numberParameters_,parameters_)].intValue(); 2442 2957 if (pumpTune>0) { 2443 2958 /* … … 2477 2992 model->solver()->getDblParam(OsiDualObjectiveLimit,cutoff); 2478 2993 cutoff = CoinMin(cutoff,value + 0.1*fabs(value)*c); 2479 double dextra1 = parameters [whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();2994 double dextra1 = parameters_[whichParam(DEXTRA1,numberParameters_,parameters_)].doubleValue(); 2480 2995 if (dextra1) 2481 2996 cutoff=dextra1; … … 2488 3003 //double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12); 2489 3004 double increment = 0.0; 2490 double dextra2 = parameters [whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();3005 double dextra2 = parameters_[whichParam(DEXTRA2,numberParameters_,parameters_)].doubleValue(); 2491 3006 if (dextra2) 2492 3007 increment = dextra2; … … 2615 3130 */ 2616 3131 3132 #ifndef NEW_STYLE_SOLVER 2617 3133 int CbcMain1 (int argc, const char *argv[], 2618 3134 CbcModel & model, 2619 int callBack(CbcModel * currentSolver, int whereFrom), 2620 int call_CbcClpUnitTest_on_777) 3135 int callBack(CbcModel * currentSolver, int whereFrom)) 3136 #else 3137 /* This takes a list of commands, does "stuff" and returns 3138 returnMode - 3139 0 model and solver untouched - babModel updated 3140 1 model updated - just with solution basis etc 3141 2 model updated i.e. as babModel (babModel NULL) 3142 */ 3143 int 3144 CbcSolver::solve (int argc, const char *argv[], int returnMode) 3145 #endif 2621 3146 { 3147 #ifndef NEW_STYLE_SOLVER 3148 CbcOrClpParam * parameters_ = parameters; 3149 int numberParameters_ = numberParameters; 3150 CbcModel & model_ = model; 3151 CbcModel * babModel_ = NULL; 3152 int returnMode=1; 3153 #else 3154 delete babModel_; 3155 babModel_ = NULL; 3156 #endif 2622 3157 /* Note 2623 3158 This is meant as a stand-alone executable to do as much of coin as possible. 2624 3159 It should only have one solver known to it. 2625 3160 */ 2626 OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model .solver());3161 OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver()); 2627 3162 assert (originalSolver); 2628 CoinMessageHandler * generalMessageHandler = model .messageHandler();3163 CoinMessageHandler * generalMessageHandler = model_.messageHandler(); 2629 3164 generalMessageHandler->setPrefix(false); 2630 3165 // Move handler across if not default … … 2635 3170 if (originalSolver->getModelPtr()->logLevel()==0) 2636 3171 noPrinting=true; 3172 #ifndef NEW_STYLE_SOLVER 3173 bool noPrinting_=noPrinting; 3174 #endif 2637 3175 // see if log in list 2638 3176 for (int i=1;i<argc;i++) { … … 2640 3178 const char * equals = strchr(argv[i],'='); 2641 3179 if (equals&&atoi(equals+1)>0) 2642 noPrinting =false;3180 noPrinting_=false; 2643 3181 else 2644 noPrinting =true;3182 noPrinting_=true; 2645 3183 break; 2646 3184 } else if (!strncmp(argv[i],"-log",4)&&i<argc-1) { 2647 3185 if (atoi(argv[i+1])>0) 2648 noPrinting =false;3186 noPrinting_=false; 2649 3187 else 2650 noPrinting =true;3188 noPrinting_=true; 2651 3189 break; 2652 3190 } 2653 3191 } 2654 CbcModel * babModel = NULL;2655 3192 double time0; 2656 3193 { … … 2669 3206 // 0 normal, 1 from ampl or MIQP etc (2 allows cuts) 2670 3207 int complicatedInteger=0; 2671 OsiSolverInterface * solver = model .solver();3208 OsiSolverInterface * solver = model_.solver(); 2672 3209 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver); 2673 3210 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 2674 if (noPrinting ) {3211 if (noPrinting_) { 2675 3212 setCbcOrClpPrinting(false); 2676 3213 lpSolver->setLogLevel(0); … … 2704 3241 usingAmpl=true; 2705 3242 // see if log in list 2706 noPrinting =true;3243 noPrinting_=true; 2707 3244 for (int i=1;i<argc;i++) { 2708 3245 if (!strncmp(argv[i],"log",3)) { 2709 3246 const char * equals = strchr(argv[i],'='); 2710 3247 if (equals&&atoi(equals+1)>0) { 2711 noPrinting =false;3248 noPrinting_=false; 2712 3249 info.logLevel=atoi(equals+1); 2713 int log = whichParam(LOGLEVEL,numberParameters ,parameters);2714 parameters [log].setIntValue(info.logLevel);3250 int log = whichParam(LOGLEVEL,numberParameters_,parameters_); 3251 parameters_[log].setIntValue(info.logLevel); 2715 3252 // mark so won't be overWritten 2716 3253 info.numberRows=-1234567; … … 2727 3264 if (!strcmp(info.arguments[i],"log")) { 2728 3265 if (i<info.numberArguments-1&&atoi(info.arguments[i+1])>0) 2729 noPrinting =false;3266 noPrinting_=false; 2730 3267 break; 2731 3268 } 2732 3269 } 2733 if (noPrinting ) {2734 model .messageHandler()->setLogLevel(0);3270 if (noPrinting_) { 3271 model_.messageHandler()->setLogLevel(0); 2735 3272 setCbcOrClpPrinting(false); 2736 3273 } 2737 if (!noPrinting )3274 if (!noPrinting_) 2738 3275 printf("%d rows, %d columns and %d elements\n", 2739 3276 info.numberRows,info.numberColumns,info.numberElements); … … 2781 3318 OsiSolverLink solver1; 2782 3319 OsiSolverInterface * solver2 = solver1.clone(); 2783 model .assignSolver(solver2,false);3320 model_.assignSolver(solver2,false); 2784 3321 OsiSolverLink * si = 2785 dynamic_cast<OsiSolverLink *>(model .solver()) ;3322 dynamic_cast<OsiSolverLink *>(model_.solver()) ; 2786 3323 assert (si != NULL); 2787 3324 si->setDefaultMeshSize(0.001); 2788 3325 // need some relative granularity 2789 3326 si->setDefaultBound(100.0); 2790 double dextra3 = parameters [whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();3327 double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue(); 2791 3328 if (dextra3) 2792 3329 si->setDefaultMeshSize(dextra3); … … 2795 3332 si->setBiLinearPriority(10000); 2796 3333 CoinModel * model2 = (CoinModel *) coinModel; 2797 int logLevel = whichParam(LOGLEVEL,numberParameters ,parameters);3334 int logLevel = whichParam(LOGLEVEL,numberParameters_,parameters_); 2798 3335 si->load(*model2,true,logLevel); 2799 3336 // redo 2800 solver = model .solver();3337 solver = model_.solver(); 2801 3338 clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver); 2802 3339 lpSolver = clpSolver->getModelPtr(); 2803 3340 clpSolver->messageHandler()->setLogLevel(0) ; 2804 3341 testOsiParameters=0; 2805 parameters [whichParam(TESTOSI,numberParameters,parameters)].setIntValue(0);3342 parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(0); 2806 3343 complicatedInteger=1; 2807 3344 if (info.cut) { … … 2932 3469 std::string solutionFile ="stdout"; 2933 3470 std::string solutionSaveFile ="solution.file"; 2934 int slog = whichParam(SOLVERLOGLEVEL,numberParameters ,parameters);2935 int log = whichParam(LOGLEVEL,numberParameters ,parameters);2936 double normalIncrement=model .getCutoffIncrement();;3471 int slog = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_); 3472 int log = whichParam(LOGLEVEL,numberParameters_,parameters_); 3473 double normalIncrement=model_.getCutoffIncrement();; 2937 3474 if (testOsiParameters>=0) { 2938 3475 // trying nonlinear - switch off some stuff … … 3027 3564 3028 3565 std::string field; 3029 if (!noPrinting ) {3566 if (!noPrinting_) { 3030 3567 sprintf(generalPrint,"Coin Cbc and Clp Solver version %s, build %s", 3031 3568 CBCVERSION,__DATE__); … … 3094 3631 int numberMatches=0; 3095 3632 int firstMatch=-1; 3096 for ( iParam=0; iParam<numberParameters ; iParam++ ) {3097 int match = parameters [iParam].matches(field);3633 for ( iParam=0; iParam<numberParameters_; iParam++ ) { 3634 int match = parameters_[iParam].matches(field); 3098 3635 if (match==1) { 3099 3636 numberMatches = 1; … … 3106 3643 } 3107 3644 } 3108 if (iParam<numberParameters &&!numberQuery) {3645 if (iParam<numberParameters_&&!numberQuery) { 3109 3646 // found 3110 CbcOrClpParam found = parameters [iParam];3647 CbcOrClpParam found = parameters_[iParam]; 3111 3648 CbcOrClpParameterType type = found.type(); 3112 3649 int valid; … … 3122 3659 lpSolver = clpSolver->getModelPtr(); 3123 3660 if (!lpSolver->integerInformation()&&!numberSOS&& 3124 !clpSolver->numberSOS()&&!model .numberObjects()&&!clpSolver->numberObjects())3661 !clpSolver->numberSOS()&&!model_.numberObjects()&&!clpSolver->numberObjects()) 3125 3662 type=DUALSIMPLEX; 3126 3663 } … … 3171 3708 if ((verbose&2)!=0) 3172 3709 std::cout<<std::endl; 3173 for ( iParam=0; iParam<numberParameters ; iParam++ ) {3174 int type = parameters [iParam].type();3175 if ((parameters [iParam].displayThis()||evenHidden)&&3710 for ( iParam=0; iParam<numberParameters_; iParam++ ) { 3711 int type = parameters_[iParam].type(); 3712 if ((parameters_[iParam].displayThis()||evenHidden)&& 3176 3713 type>=limits[iType] 3177 3714 &&type<limits[iType+1]) { 3178 3715 // but skip if not useful for ampl (and in ampl mode) 3179 if (verbose>=4&&(parameters [iParam].whereUsed()&4)==0)3716 if (verbose>=4&&(parameters_[iParam].whereUsed()&4)==0) 3180 3717 continue; 3181 3718 if (!across) { … … 3185 3722 std::cout<<"Command "; 3186 3723 } 3187 std::cout<<parameters [iParam].matchName()<<" ";3724 std::cout<<parameters_[iParam].matchName()<<" "; 3188 3725 across++; 3189 3726 if (across==maxAcross) { … … 3192 3729 // put out description as well 3193 3730 if ((verbose&1)!=0) 3194 std::cout<<parameters [iParam].shortHelp();3731 std::cout<<parameters_[iParam].shortHelp(); 3195 3732 std::cout<<std::endl; 3196 3733 if ((verbose&2)!=0) { 3197 3734 std::cout<<"---- description"<<std::endl; 3198 parameters [iParam].printLongHelp();3735 parameters_[iParam].printLongHelp(); 3199 3736 std::cout<<"----"<<std::endl<<std::endl; 3200 3737 } … … 3225 3762 int across=0; 3226 3763 std::cout<<types[iType]<<" "; 3227 for ( iParam=0; iParam<numberParameters ; iParam++ ) {3228 int type = parameters [iParam].type();3764 for ( iParam=0; iParam<numberParameters_; iParam++ ) { 3765 int type = parameters_[iParam].type(); 3229 3766 if (type>=limits[iType] 3230 3767 &&type<limits[iType+1]) { 3231 3768 if (!across) 3232 3769 std::cout<<" "; 3233 std::cout<<parameters [iParam].matchName()<<" ";3770 std::cout<<parameters_[iParam].matchName()<<" "; 3234 3771 across++; 3235 3772 if (across==maxAcross) { … … 3247 3784 if (!valid) { 3248 3785 if (type<51) { 3249 parameters [iParam].setDoubleParameter(lpSolver,value);3786 parameters_[iParam].setDoubleParameter(lpSolver,value); 3250 3787 } else if (type<81) { 3251 parameters [iParam].setDoubleParameter(model,value);3788 parameters_[iParam].setDoubleParameter(model_,value); 3252 3789 } else { 3253 parameters [iParam].setDoubleParameter(lpSolver,value);3790 parameters_[iParam].setDoubleParameter(lpSolver,value); 3254 3791 switch(type) { 3255 3792 case DJFIX: … … 3257 3794 if (goodModel&&djFix<1.0e20) { 3258 3795 // do some fixing 3259 clpSolver = dynamic_cast< OsiClpSolverInterface*> (model .solver());3796 clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver()); 3260 3797 clpSolver->initialSolve(); 3261 3798 lpSolver = clpSolver->getModelPtr(); … … 3268 3805 double * dj = lpSolver->dualColumnSolution(); 3269 3806 int numberFixed=0; 3270 double dextra4 = parameters [whichParam(DEXTRA4,numberParameters,parameters)].doubleValue();3807 double dextra4 = parameters_[whichParam(DEXTRA4,numberParameters_,parameters_)].doubleValue(); 3271 3808 if (dextra4) 3272 3809 printf("Multiple for continuous dj fixing is %g\n",dextra4); … … 3307 3844 } 3308 3845 } else if (valid==1) { 3309 std::cout<<" is illegal for double parameter "<<parameters [iParam].name()<<" value remains "<<3310 parameters [iParam].doubleValue()<<std::endl;3846 std::cout<<" is illegal for double parameter "<<parameters_[iParam].name()<<" value remains "<< 3847 parameters_[iParam].doubleValue()<<std::endl; 3311 3848 } else { 3312 std::cout<<parameters [iParam].name()<<" has value "<<3313 parameters [iParam].doubleValue()<<std::endl;3849 std::cout<<parameters_[iParam].name()<<" has value "<< 3850 parameters_[iParam].doubleValue()<<std::endl; 3314 3851 } 3315 3852 } else if (type<201) { … … 3318 3855 if (!valid) { 3319 3856 if (type<151) { 3320 if (parameters [iParam].type()==PRESOLVEPASS)3857 if (parameters_[iParam].type()==PRESOLVEPASS) 3321 3858 preSolve = value; 3322 else if (parameters [iParam].type()==IDIOT)3859 else if (parameters_[iParam].type()==IDIOT) 3323 3860 doIdiot = value; 3324 else if (parameters [iParam].type()==SPRINT)3861 else if (parameters_[iParam].type()==SPRINT) 3325 3862 doSprint = value; 3326 else if (parameters [iParam].type()==OUTPUTFORMAT)3863 else if (parameters_[iParam].type()==OUTPUTFORMAT) 3327 3864 outputFormat = value; 3328 else if (parameters [iParam].type()==SLPVALUE)3865 else if (parameters_[iParam].type()==SLPVALUE) 3329 3866 slpValue = value; 3330 else if (parameters [iParam].type()==CPP)3867 else if (parameters_[iParam].type()==CPP) 3331 3868 cppValue = value; 3332 else if (parameters [iParam].type()==PRESOLVEOPTIONS)3869 else if (parameters_[iParam].type()==PRESOLVEOPTIONS) 3333 3870 presolveOptions = value; 3334 else if (parameters [iParam].type()==PRINTOPTIONS)3871 else if (parameters_[iParam].type()==PRINTOPTIONS) 3335 3872 printOptions = value; 3336 else if (parameters [iParam].type()==SUBSTITUTION)3873 else if (parameters_[iParam].type()==SUBSTITUTION) 3337 3874 substitution = value; 3338 else if (parameters [iParam].type()==DUALIZE)3875 else if (parameters_[iParam].type()==DUALIZE) 3339 3876 dualize = value; 3340 else if (parameters [iParam].type()==PROCESSTUNE)3877 else if (parameters_[iParam].type()==PROCESSTUNE) 3341 3878 tunePreProcess = value; 3342 else if (parameters [iParam].type()==VERBOSE)3879 else if (parameters_[iParam].type()==VERBOSE) 3343 3880 verbose = value; 3344 parameters [iParam].setIntParameter(lpSolver,value);3881 parameters_[iParam].setIntParameter(lpSolver,value); 3345 3882 } else { 3346 if (parameters [iParam].type()==CUTPASS)3883 if (parameters_[iParam].type()==CUTPASS) 3347 3884 cutPass = value; 3348 else if (parameters [iParam].type()==CUTPASSINTREE)3885 else if (parameters_[iParam].type()==CUTPASSINTREE) 3349 3886 cutPassInTree = value; 3350 else if (parameters [iParam].type()==STRONGBRANCHING||3351 parameters [iParam].type()==NUMBERBEFORE)3887 else if (parameters_[iParam].type()==STRONGBRANCHING|| 3888 parameters_[iParam].type()==NUMBERBEFORE) 3352 3889 strongChanged=true; 3353 parameters [iParam].setIntParameter(model,value);3890 parameters_[iParam].setIntParameter(model_,value); 3354 3891 } 3355 3892 } else if (valid==1) { 3356 std::cout<<" is illegal for integer parameter "<<parameters [iParam].name()<<" value remains "<<3357 parameters [iParam].intValue()<<std::endl;3893 std::cout<<" is illegal for integer parameter "<<parameters_[iParam].name()<<" value remains "<< 3894 parameters_[iParam].intValue()<<std::endl; 3358 3895 } else { 3359 std::cout<<parameters [iParam].name()<<" has value "<<3360 parameters [iParam].intValue()<<std::endl;3896 std::cout<<parameters_[iParam].name()<<" has value "<< 3897 parameters_[iParam].intValue()<<std::endl; 3361 3898 } 3362 3899 } else if (type<301) { 3363 3900 // one of several strings 3364 3901 std::string value = CoinReadGetString(argc,argv); 3365 int action = parameters [iParam].parameterOption(value);3902 int action = parameters_[iParam].parameterOption(value); 3366 3903 if (action<0) { 3367 3904 if (value!="EOL") { 3368 3905 // no match 3369 parameters [iParam].printOptions();3906 parameters_[iParam].printOptions(); 3370 3907 } else { 3371 3908 // print current value 3372 std::cout<<parameters [iParam].name()<<" has value "<<3373 parameters [iParam].currentOption()<<std::endl;3909 std::cout<<parameters_[iParam].name()<<" has value "<< 3910 parameters_[iParam].currentOption()<<std::endl; 3374 3911 } 3375 3912 } else { 3376 parameters [iParam].setCurrentOption(action,!noPrinting);3913 parameters_[iParam].setCurrentOption(action,!noPrinting_); 3377 3914 // for now hard wired 3378 3915 switch (type) { … … 3557 4094 twomirAction = action; 3558 4095 //landpAction = action; 3559 parameters [whichParam(GOMORYCUTS,numberParameters,parameters)].setCurrentOption(action);3560 parameters [whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption(action);3561 parameters [whichParam(KNAPSACKCUTS,numberParameters,parameters)].setCurrentOption(action);3562 parameters [whichParam(CLIQUECUTS,numberParameters,parameters)].setCurrentOption(action);3563 parameters [whichParam(FLOWCUTS,numberParameters,parameters)].setCurrentOption(action);3564 parameters [whichParam(MIXEDCUTS,numberParameters,parameters)].setCurrentOption(action);3565 parameters [whichParam(TWOMIRCUTS,numberParameters,parameters)].setCurrentOption(action);4096 parameters_[whichParam(GOMORYCUTS,numberParameters_,parameters_)].setCurrentOption(action); 4097 parameters_[whichParam(PROBINGCUTS,numberParameters_,parameters_)].setCurrentOption(action); 4098 parameters_[whichParam(KNAPSACKCUTS,numberParameters_,parameters_)].setCurrentOption(action); 4099 parameters_[whichParam(CLIQUECUTS,numberParameters_,parameters_)].setCurrentOption(action); 4100 parameters_[whichParam(FLOWCUTS,numberParameters_,parameters_)].setCurrentOption(action); 4101 parameters_[whichParam(MIXEDCUTS,numberParameters_,parameters_)].setCurrentOption(action); 4102 parameters_[whichParam(TWOMIRCUTS,numberParameters_,parameters_)].setCurrentOption(action); 3566 4103 if (!action) { 3567 4104 redsplitAction = action; 3568 parameters [whichParam(REDSPLITCUTS,numberParameters,parameters)].setCurrentOption(action);4105 parameters_[whichParam(REDSPLITCUTS,numberParameters_,parameters_)].setCurrentOption(action); 3569 4106 landpAction = action; 3570 parameters [whichParam(LANDPCUTS,numberParameters,parameters)].setCurrentOption(action);4107 parameters_[whichParam(LANDPCUTS,numberParameters_,parameters_)].setCurrentOption(action); 3571 4108 residualCapacityAction = action; 3572 parameters [whichParam(RESIDCUTS,numberParameters,parameters)].setCurrentOption(action);4109 parameters_[whichParam(RESIDCUTS,numberParameters_,parameters_)].setCurrentOption(action); 3573 4110 } 3574 4111 break; 3575 4112 case HEURISTICSTRATEGY: 3576 parameters [whichParam(ROUNDING,numberParameters,parameters)].setCurrentOption(action);3577 parameters [whichParam(GREEDY,numberParameters,parameters)].setCurrentOption(action);3578 parameters [whichParam(COMBINE,numberParameters,parameters)].setCurrentOption(action);3579 //parameters [whichParam(LOCALTREE,numberParameters,parameters)].setCurrentOption(action);3580 parameters [whichParam(FPUMP,numberParameters,parameters)].setCurrentOption(action);4113 parameters_[whichParam(ROUNDING,numberParameters_,parameters_)].setCurrentOption(action); 4114 parameters_[whichParam(GREEDY,numberParameters_,parameters_)].setCurrentOption(action); 4115 parameters_[whichParam(COMBINE,numberParameters_,parameters_)].setCurrentOption(action); 4116 //parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].setCurrentOption(action); 4117 parameters_[whichParam(FPUMP,numberParameters_,parameters_)].setCurrentOption(action); 3581 4118 break; 3582 4119 case GREEDY: … … 3629 4166 if (goodModel) { 3630 4167 double objScale = 3631 parameters [whichParam(OBJSCALE2,numberParameters,parameters)].doubleValue();4168 parameters_[whichParam(OBJSCALE2,numberParameters_,parameters_)].doubleValue(); 3632 4169 if (objScale!=1.0) { 3633 4170 int iColumn; … … 3664 4201 model2->setOptimizationDirection(1.0); 3665 4202 } 3666 if (noPrinting )4203 if (noPrinting_) 3667 4204 lpSolver->setLogLevel(0); 3668 4205 ClpSolve solveOptions; … … 3776 4313 solveOptions.setSpecialOption(4,barrierOptions); 3777 4314 } 3778 model2->setMaximumSeconds(model .getMaximumSeconds());4315 model2->setMaximumSeconds(model_.getMaximumSeconds()); 3779 4316 #ifdef COIN_HAS_LINK 3780 OsiSolverInterface * coinSolver = model .solver();4317 OsiSolverInterface * coinSolver = model_.solver(); 3781 4318 OsiSolverLink * linkSolver = dynamic_cast< OsiSolverLink*> (coinSolver); 3782 4319 if (!linkSolver) { … … 3784 4321 } else { 3785 4322 // special solver 3786 int testOsiOptions = parameters [whichParam(TESTOSI,numberParameters,parameters)].intValue();4323 int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue(); 3787 4324 double * solution = NULL; 3788 4325 if (testOsiOptions<10) { … … 3871 4408 iStatus2=0; 3872 4409 } 3873 model .setProblemStatus(iStatus);3874 model .setSecondaryStatus(iStatus2);4410 model_.setProblemStatus(iStatus); 4411 model_.setSecondaryStatus(iStatus2); 3875 4412 assert (lpSolver==clpSolver->getModelPtr()); 3876 assert (clpSolver==model .solver());4413 assert (clpSolver==model_.solver()); 3877 4414 clpSolver->setWarmStart(NULL); 3878 4415 // and in babModel if exists 3879 if (babModel ) {3880 babModel ->setProblemStatus(iStatus);3881 babModel ->setSecondaryStatus(iStatus2);4416 if (babModel_) { 4417 babModel_->setProblemStatus(iStatus); 4418 babModel_->setSecondaryStatus(iStatus2); 3882 4419 } 4420 #ifdef NEW_STYLE_SOLVER 4421 int returnCode = callBack_->callBack(&model_,1); 4422 #else 3883 4423 int returnCode=callBack(&model,1); 4424 #endif 3884 4425 if (returnCode) { 3885 4426 // exit if user wants 3886 delete babModel; 4427 #ifdef NEW_STYLE_SOLVER 4428 updateModel(model2,returnMode); 4429 #else 4430 delete babModel_; 4431 babModel_ = NULL; 4432 #endif 3887 4433 return returnCode; 3888 4434 } … … 3977 4523 pinfo.statistics(); 3978 4524 double presolveTolerance = 3979 parameters [whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();4525 parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].doubleValue(); 3980 4526 model2 = 3981 4527 pinfo.presolvedModel(*lpSolver,presolveTolerance, … … 4042 4588 storedCuts = dupcuts.outDuplicates(clpSolver)!=0; 4043 4589 int nOut = numberRows-clpSolver->getNumRows(); 4044 if (nOut&&!noPrinting )4590 if (nOut&&!noPrinting_) 4045 4591 sprintf(generalPrint,"%d rows eliminated",nOut); 4046 4592 generalMessageHandler->message(CLP_GENERAL,generalMessages) … … 4078 4624 case DOHEURISTIC: 4079 4625 if (goodModel) { 4080 int vubAction = parameters [whichParam(VUBTRY,numberParameters,parameters)].intValue();4626 int vubAction = parameters_[whichParam(VUBTRY,numberParameters_,parameters_)].intValue(); 4081 4627 if (vubAction!=-1) { 4082 4628 // look at vubs 4083 4629 // Just ones which affect >= extra3 4084 int extra3 = parameters [whichParam(EXTRA3,numberParameters,parameters)].intValue();4630 int extra3 = parameters_[whichParam(EXTRA3,numberParameters_,parameters_)].intValue(); 4085 4631 /* 3 is fraction of integer variables fixed (0.97) 4086 4632 4 is fraction of all variables fixed (0.0) 4087 4633 */ 4088 4634 double dextra[5]; 4089 dextra[1] = parameters [whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();4090 dextra[2] = parameters [whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();4091 dextra[3] = parameters [whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();4092 dextra[4] = parameters [whichParam(DEXTRA4,numberParameters,parameters)].doubleValue();4635 dextra[1] = parameters_[whichParam(DEXTRA1,numberParameters_,parameters_)].doubleValue(); 4636 dextra[2] = parameters_[whichParam(DEXTRA2,numberParameters_,parameters_)].doubleValue(); 4637 dextra[3] = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue(); 4638 dextra[4] = parameters_[whichParam(DEXTRA4,numberParameters_,parameters_)].doubleValue(); 4093 4639 if (!dextra[3]) 4094 4640 dextra[3] = 0.97; 4095 OsiClpSolverInterface * newSolver = fixVubs(model ,extra3,vubAction,generalMessageHandler,4641 OsiClpSolverInterface * newSolver = fixVubs(model_,extra3,vubAction,generalMessageHandler, 4096 4642 debugValues,dextra); 4097 4643 assert (!newSolver); 4098 4644 } 4099 4645 // Actually do heuristics 4100 doHeuristics(&model ,2);4101 if (model .bestSolution()) {4102 model .setProblemStatus(1);4103 model .setSecondaryStatus(6);4646 doHeuristics(&model_,2); 4647 if (model_.bestSolution()) { 4648 model_.setProblemStatus(1); 4649 model_.setSecondaryStatus(6); 4104 4650 } 4651 #ifdef NEW_STYLE_SOLVER 4652 int returnCode = callBack_->callBack(&model_,6); 4653 #else 4105 4654 int returnCode=callBack(&model,6); 4655 #endif 4106 4656 if (returnCode) { 4107 4657 // exit if user wants 4108 delete babModel; 4658 #ifdef NEW_STYLE_SOLVER 4659 updateModel(NULL,returnMode); 4660 #else 4661 delete babModel_; 4662 babModel_ = NULL; 4663 #endif 4109 4664 return returnCode; 4110 4665 } … … 4122 4677 if (goodModel) { 4123 4678 bool miplib = type==MIPLIB; 4124 int logLevel = parameters [slog].intValue();4679 int logLevel = parameters_[slog].intValue(); 4125 4680 // Reduce printout 4126 4681 if (logLevel<=1) 4127 model .solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);4682 model_.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry); 4128 4683 { 4129 OsiSolverInterface * solver = model .solver();4684 OsiSolverInterface * solver = model_.solver(); 4130 4685 OsiClpSolverInterface * si = 4131 4686 dynamic_cast<OsiClpSolverInterface *>(solver) ; … … 4138 4693 if (obj) { 4139 4694 preProcess=0; 4140 int testOsiOptions = parameters [whichParam(TESTOSI,numberParameters,parameters)].intValue();4141 parameters [whichParam(TESTOSI,numberParameters,parameters)].setIntValue(CoinMax(0,testOsiOptions));4695 int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue(); 4696 parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(CoinMax(0,testOsiOptions)); 4142 4697 // create coin model 4143 4698 coinModel = lpSolver->createCoinModel(); … … 4146 4701 OsiSolverLink solver1; 4147 4702 OsiSolverInterface * solver2 = solver1.clone(); 4148 model .assignSolver(solver2,false);4703 model_.assignSolver(solver2,false); 4149 4704 OsiSolverLink * si = 4150 dynamic_cast<OsiSolverLink *>(model .solver()) ;4705 dynamic_cast<OsiSolverLink *>(model_.solver()) ; 4151 4706 assert (si != NULL); 4152 4707 si->setDefaultMeshSize(0.001); 4153 4708 // need some relative granularity 4154 4709 si->setDefaultBound(100.0); 4155 double dextra3 = parameters [whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();4710 double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue(); 4156 4711 if (dextra3) 4157 4712 si->setDefaultMeshSize(dextra3); … … 4161 4716 si->setSpecialOptions2(2+4+8); 4162 4717 CoinModel * model2 = (CoinModel *) coinModel; 4163 si->load(*model2,true, parameters [log].intValue());4718 si->load(*model2,true, parameters_[log].intValue()); 4164 4719 // redo 4165 solver = model .solver();4720 solver = model_.solver(); 4166 4721 clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver); 4167 4722 lpSolver = clpSolver->getModelPtr(); … … 4169 4724 testOsiParameters=0; 4170 4725 complicatedInteger=2; // allow cuts 4171 OsiSolverInterface * coinSolver = model .solver();4726 OsiSolverInterface * coinSolver = model_.solver(); 4172 4727 OsiSolverLink * linkSolver = dynamic_cast< OsiSolverLink*> (coinSolver); 4173 4728 if (linkSolver->quadraticModel()) { … … 4291 4846 cbcModel->initialSolve(); 4292 4847 #ifdef CBC_THREAD 4293 int numberThreads =parameters [whichParam(THREADS,numberParameters,parameters)].intValue();4848 int numberThreads =parameters_[whichParam(THREADS,numberParameters_,parameters_)].intValue(); 4294 4849 cbcModel->setNumberThreads(numberThreads%100); 4295 4850 cbcModel->setThreadMode(numberThreads/100); … … 4302 4857 linkSolver->setBestObjectiveValue(bestObjectiveValue); 4303 4858 linkSolver->setBestSolution(solution,solver3->getNumCols()); 4304 CbcHeuristicDynamic3 dynamic(model );4859 CbcHeuristicDynamic3 dynamic(model_); 4305 4860 dynamic.setHeuristicName("dynamic pass thru"); 4306 model .addHeuristic(&dynamic);4861 model_.addHeuristic(&dynamic); 4307 4862 // if convex 4308 4863 if ((linkSolver->specialOptions2()&4)!=0) { … … 4342 4897 if (!miplib) { 4343 4898 if (!preSolve) { 4344 model .solver()->setHintParam(OsiDoPresolveInInitial,false,OsiHintTry);4345 model .solver()->setHintParam(OsiDoPresolveInResolve,false,OsiHintTry);4899 model_.solver()->setHintParam(OsiDoPresolveInInitial,false,OsiHintTry); 4900 model_.solver()->setHintParam(OsiDoPresolveInResolve,false,OsiHintTry); 4346 4901 } 4347 4902 double time1a = CoinCpuTime(); 4348 model .initialSolve();4349 OsiSolverInterface * solver = model .solver();4903 model_.initialSolve(); 4904 OsiSolverInterface * solver = model_.solver(); 4350 4905 OsiClpSolverInterface * si = 4351 4906 dynamic_cast<OsiClpSolverInterface *>(solver) ; … … 4371 4926 iStatus2=0; 4372 4927 } 4373 model .setProblemStatus(iStatus);4374 model .setSecondaryStatus(iStatus2);4928 model_.setProblemStatus(iStatus); 4929 model_.setSecondaryStatus(iStatus2); 4375 4930 si->setWarmStart(NULL); 4376 int returnCode=callBack(&model,1); 4931 #ifdef NEW_STYLE_SOLVER 4932 int returnCode = callBack_->callBack(&model_,1); 4933 #else 4934 int returnCode=callBack(&model_,1); 4935 #endif 4377 4936 if (returnCode) { 4378 4937 // exit if user wants 4379 delete babModel; 4938 #ifdef NEW_STYLE_SOLVER 4939 updateModel(NULL,returnMode); 4940 #else 4941 delete babModel_; 4942 babModel_ = NULL; 4943 #endif 4380 4944 return returnCode; 4381 4945 } 4382 4946 clpSolver->setSpecialOptions(clpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound) 4383 if (!noPrinting ) {4947 if (!noPrinting_) { 4384 4948 sprintf(generalPrint,"Continuous objective value is %g - %.2f seconds", 4385 4949 solver->getObjValue(),CoinCpuTime()-time1a); … … 4392 4956 std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl; 4393 4957 #endif 4394 model .setProblemStatus(0);4395 model .setSecondaryStatus(1);4958 model_.setProblemStatus(0); 4959 model_.setSecondaryStatus(1); 4396 4960 // and in babModel if exists 4397 if (babModel ) {4398 babModel ->setProblemStatus(0);4399 babModel ->setSecondaryStatus(1);4961 if (babModel_) { 4962 babModel_->setProblemStatus(0); 4963 babModel_->setSecondaryStatus(1); 4400 4964 } 4401 4965 break; … … 4446 5010 largest = CoinMax(largest,below); 4447 5011 } 4448 //if (!noPrinting )5012 //if (!noPrinting_) 4449 5013 //std::cout<<"Largest (scaled) away from bound "<<largest<<std::endl; 4450 5014 clpSolver->setDualBound(CoinMax(1.0001e8,CoinMin(1000.0*largest,1.00001e10))); … … 4454 5018 // If user made settings then use them 4455 5019 if (!defaultSettings) { 4456 OsiSolverInterface * solver = model .solver();5020 OsiSolverInterface * solver = model_.solver(); 4457 5021 if (!doScaling) 4458 5022 solver->setHintParam(OsiDoScale,false,OsiHintTry); … … 4472 5036 std::cout<<"Problem is infeasible!"<<std::endl; 4473 5037 #endif 4474 model .setProblemStatus(0);4475 model .setSecondaryStatus(1);5038 model_.setProblemStatus(0); 5039 model_.setSecondaryStatus(1); 4476 5040 // and in babModel if exists 4477 if (babModel ) {4478 babModel ->setProblemStatus(0);4479 babModel ->setSecondaryStatus(1);5041 if (babModel_) { 5042 babModel_->setProblemStatus(0); 5043 babModel_->setSecondaryStatus(1); 4480 5044 } 4481 5045 break; … … 4488 5052 // Say integers in sync 4489 5053 bool integersOK=true; 4490 delete babModel ;4491 babModel = new CbcModel(model);5054 delete babModel_; 5055 babModel_ = new CbcModel(model_); 4492 5056 OsiSolverInterface * solver3 = clpSolver->clone(); 4493 babModel ->assignSolver(solver3);4494 OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());5057 babModel_->assignSolver(solver3); 5058 OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 4495 5059 int numberChanged=0; 4496 5060 if (clpSolver2->messageHandler()->logLevel()) … … 4521 5085 totalTime += time2-time1; 4522 5086 time1 = time2; 4523 double timeLeft = babModel ->getMaximumSeconds();4524 int numberOriginalColumns = babModel ->solver()->getNumCols();5087 double timeLeft = babModel_->getMaximumSeconds(); 5088 int numberOriginalColumns = babModel_->solver()->getNumCols(); 4525 5089 if (preProcess==7) { 4526 5090 // use strategy instead … … 4568 5132 } 4569 5133 } 4570 saveSolver=babModel ->solver()->clone();5134 saveSolver=babModel_->solver()->clone(); 4571 5135 /* Do not try and produce equality cliques and 4572 5136 do up to 10 passes */ … … 4586 5150 process.addCutGenerator(&generator1); 4587 5151 int translate[]={9999,0,0,-1,2,3,-2}; 4588 process.passInMessageHandler(babModel ->messageHandler());4589 //process.messageHandler()->setLogLevel(babModel ->logLevel());5152 process.passInMessageHandler(babModel_->messageHandler()); 5153 //process.messageHandler()->setLogLevel(babModel_->logLevel()); 4590 5154 #ifdef COIN_HAS_ASL 4591 5155 if (info.numberSos&&doSOS&&usingAmpl) { … … 4609 5173 delete [] prohibited; 4610 5174 } 4611 if (model .numberObjects()) {4612 OsiObject ** oldObjects = babModel ->objects();4613 int numberOldObjects = babModel ->numberObjects();5175 if (model_.numberObjects()) { 5176 OsiObject ** oldObjects = babModel_->objects(); 5177 int numberOldObjects = babModel_->numberObjects(); 4614 5178 // SOS 4615 5179 int numberColumns = saveSolver->getNumCols(); … … 4684 5248 } 4685 5249 #endif 4686 if (!noPrinting ) {5250 if (!noPrinting_) { 4687 5251 if (!solver2) { 4688 5252 sprintf(generalPrint,"Pre-processing says infeasible or unbounded"); … … 4696 5260 } 4697 5261 if (!solver2) { 4698 model .setProblemStatus(0);4699 model .setSecondaryStatus(1);4700 babModel ->setProblemStatus(0);4701 babModel ->setSecondaryStatus(1);5262 model_.setProblemStatus(0); 5263 model_.setSecondaryStatus(1); 5264 babModel_->setProblemStatus(0); 5265 babModel_->setSecondaryStatus(1); 4702 5266 } else { 4703 model .setProblemStatus(-1);4704 babModel ->setProblemStatus(-1);5267 model_.setProblemStatus(-1); 5268 babModel_->setProblemStatus(-1); 4705 5269 } 4706 int returnCode=callBack(babModel,2); 5270 #ifdef NEW_STYLE_SOLVER 5271 int returnCode = callBack_->callBack(babModel_,2); 5272 #else 5273 int returnCode=callBack(babModel_,2); 5274 #endif 4707 5275 if (returnCode) { 4708 5276 // exit if user wants 4709 delete babModel; 5277 #ifdef NEW_STYLE_SOLVER 5278 updateModel(NULL,returnMode); 5279 #else 5280 delete babModel_; 5281 babModel_ = NULL; 5282 #endif 4710 5283 return returnCode; 4711 5284 } 4712 5285 if (!solver2) 4713 5286 break; 4714 if (model .bestSolution()) {5287 if (model_.bestSolution()) { 4715 5288 // need to redo - in case no better found in BAB 4716 5289 // just get integer part right 4717 5290 const int * originalColumns = process.originalColumns(); 4718 5291 int numberColumns = solver2->getNumCols(); 4719 double * bestSolution = babModel ->bestSolution();4720 const double * oldBestSolution = model .bestSolution();5292 double * bestSolution = babModel_->bestSolution(); 5293 const double * oldBestSolution = model_.bestSolution(); 4721 5294 for (int i=0;i<numberColumns;i++) { 4722 5295 int jColumn = originalColumns[i]; … … 4733 5306 // we have to keep solver2 so pass clone 4734 5307 solver2 = solver2->clone(); 4735 babModel ->assignSolver(solver2);4736 babModel ->setOriginalColumns(process.originalColumns());4737 babModel ->initialSolve();4738 babModel ->setMaximumSeconds(timeLeft-(CoinCpuTime()-time1));5308 babModel_->assignSolver(solver2); 5309 babModel_->setOriginalColumns(process.originalColumns()); 5310 babModel_->initialSolve(); 5311 babModel_->setMaximumSeconds(timeLeft-(CoinCpuTime()-time1)); 4739 5312 } 4740 5313 // now tighten bounds 4741 5314 if (!miplib) { 4742 5315 OsiClpSolverInterface * si = 4743 dynamic_cast<OsiClpSolverInterface *>(babModel ->solver()) ;5316 dynamic_cast<OsiClpSolverInterface *>(babModel_->solver()) ; 4744 5317 assert (si != NULL); 4745 5318 // get clp itself 4746 5319 ClpSimplex * modelC = si->getModelPtr(); 4747 //if (noPrinting )5320 //if (noPrinting_) 4748 5321 //modelC->setLogLevel(0); 4749 5322 if (!complicatedInteger&&modelC->tightenPrimalBounds()!=0) { … … 4751 5324 std::cout<<"Problem is infeasible!"<<std::endl; 4752 5325 #endif 4753 model .setProblemStatus(0);4754 model .setSecondaryStatus(1);4755 // and in babModel if exists4756 if (babModel ) {4757 babModel ->setProblemStatus(0);4758 babModel ->setSecondaryStatus(1);5326 model_.setProblemStatus(0); 5327 model_.setSecondaryStatus(1); 5328 // and in babModel_ if exists 5329 if (babModel_) { 5330 babModel_->setProblemStatus(0); 5331 babModel_->setSecondaryStatus(1); 4759 5332 } 4760 5333 break; … … 4778 5351 // for debug 4779 5352 std::string problemName ; 4780 babModel ->solver()->getStrParam(OsiProbName,problemName) ;4781 babModel ->solver()->activateRowCutDebugger(problemName.c_str()) ;5353 babModel_->solver()->getStrParam(OsiProbName,problemName) ; 5354 babModel_->solver()->activateRowCutDebugger(problemName.c_str()) ; 4782 5355 twomirGen.probname_=strdup(problemName.c_str()); 4783 5356 // checking seems odd 4784 //redsplitGen.set_given_optsol(babModel ->solver()->getRowCutDebuggerAlways()->optimalSolution(),4785 // babModel ->getNumCols());5357 //redsplitGen.set_given_optsol(babModel_->solver()->getRowCutDebuggerAlways()->optimalSolution(), 5358 // babModel_->getNumCols()); 4786 5359 } 4787 int testOsiOptions = parameters [whichParam(TESTOSI,numberParameters,parameters)].intValue();5360 int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue(); 4788 5361 #ifdef COIN_HAS_ASL 4789 5362 // If linked then see if expansion wanted 4790 5363 { 4791 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel ->solver());4792 int options = parameters [whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()/10000;5364 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver()); 5365 int options = parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].intValue()/10000; 4793 5366 if (solver3||(options&16)!=0) { 4794 5367 if (options) { … … 4807 5380 knapsackRow=new int[numberRows]; 4808 5381 numberKnapsack=10000; 4809 int extra1 = parameters [whichParam(EXTRA1,numberParameters,parameters)].intValue();4810 int extra2 = parameters [whichParam(EXTRA2,numberParameters,parameters)].intValue();4811 int logLevel = parameters [log].intValue();5382 int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue(); 5383 int extra2 = parameters_[whichParam(EXTRA2,numberParameters_,parameters_)].intValue(); 5384 int logLevel = parameters_[log].intValue(); 4812 5385 OsiSolverInterface * solver = expandKnapsack(saveCoinModel,whichColumn,knapsackStart, 4813 5386 knapsackRow,numberKnapsack, … … 4818 5391 assert (clpSolver); 4819 5392 lpSolver = clpSolver->getModelPtr(); 4820 babModel ->assignSolver(solver);5393 babModel_->assignSolver(solver); 4821 5394 testOsiOptions=0; 4822 5395 // allow gomory … … 4840 5413 #endif 4841 5414 if (useCosts&&testOsiOptions<0) { 4842 int numberColumns = babModel ->getNumCols();5415 int numberColumns = babModel_->getNumCols(); 4843 5416 int * sort = new int[numberColumns]; 4844 5417 double * dsort = new double[numberColumns]; 4845 5418 int * priority = new int [numberColumns]; 4846 const double * objective = babModel ->getObjCoefficients();4847 const double * lower = babModel ->getColLower() ;4848 const double * upper = babModel ->getColUpper() ;4849 const CoinPackedMatrix * matrix = babModel ->solver()->getMatrixByCol();5419 const double * objective = babModel_->getObjCoefficients(); 5420 const double * lower = babModel_->getColLower() ; 5421 const double * upper = babModel_->getColUpper() ; 5422 const CoinPackedMatrix * matrix = babModel_->solver()->getMatrixByCol(); 4850 5423 const int * columnLength = matrix->getVectorLengths(); 4851 5424 int iColumn; 4852 5425 int n=0; 4853 5426 for (iColumn=0;iColumn<numberColumns;iColumn++) { 4854 if (babModel ->isInteger(iColumn)) {5427 if (babModel_->isInteger(iColumn)) { 4855 5428 sort[n]=n; 4856 5429 if (useCosts==1) … … 4877 5450 priority[iPut]=level; 4878 5451 } 4879 babModel ->passInPriorities( priority,false);5452 babModel_->passInPriorities( priority,false); 4880 5453 integersOK=true; 4881 5454 delete [] priority; … … 4884 5457 } 4885 5458 // Set up heuristics 4886 doHeuristics(babModel ,(!miplib) ? 1 : 3);5459 doHeuristics(babModel_,(!miplib) ? 1 : 3); 4887 5460 if (!miplib) { 4888 if(parameters [whichParam(LOCALTREE,numberParameters,parameters)].currentOptionAsInteger()) {4889 CbcTreeLocal localTree(babModel ,NULL,10,0,0,10000,2000);4890 babModel ->passInTreeHandler(localTree);5461 if(parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].currentOptionAsInteger()) { 5462 CbcTreeLocal localTree(babModel_,NULL,10,0,0,10000,2000); 5463 babModel_->passInTreeHandler(localTree); 4891 5464 } 4892 5465 } 4893 5466 if (type==MIPLIB) { 4894 if (babModel ->numberStrong()==5&&babModel->numberBeforeTrust()==5)4895 babModel ->setNumberBeforeTrust(10);5467 if (babModel_->numberStrong()==5&&babModel_->numberBeforeTrust()==5) 5468 babModel_->setNumberBeforeTrust(10); 4896 5469 } 4897 5470 // add cut generators if wanted … … 4910 5483 probingGen.setMaxLookRoot(50); 4911 5484 } 4912 babModel ->addCutGenerator(&probingGen,translate[probingAction],"Probing");5485 babModel_->addCutGenerator(&probingGen,translate[probingAction],"Probing"); 4913 5486 switches[numberGenerators++]=0; 4914 5487 } 4915 5488 if (gomoryAction&&(complicatedInteger!=1|| 4916 5489 (gomoryAction==1||gomoryAction==4))) { 4917 babModel ->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");5490 babModel_->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory"); 4918 5491 switches[numberGenerators++]=-1; 4919 5492 } 4920 5493 if (knapsackAction) { 4921 babModel ->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack");5494 babModel_->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack"); 4922 5495 switches[numberGenerators++]=0; 4923 5496 } 4924 5497 if (redsplitAction&&!complicatedInteger) { 4925 babModel ->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");5498 babModel_->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split"); 4926 5499 switches[numberGenerators++]=1; 4927 5500 } 4928 5501 if (cliqueAction) { 4929 babModel ->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique");5502 babModel_->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique"); 4930 5503 switches[numberGenerators++]=0; 4931 5504 } 4932 5505 if (mixedAction) { 4933 babModel ->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2");5506 babModel_->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2"); 4934 5507 switches[numberGenerators++]=-1; 4935 5508 } 4936 5509 if (flowAction) { 4937 babModel ->addCutGenerator(&flowGen,translate[flowAction],"FlowCover");5510 babModel_->addCutGenerator(&flowGen,translate[flowAction],"FlowCover"); 4938 5511 switches[numberGenerators++]=1; 4939 5512 } 4940 5513 if (twomirAction&&!complicatedInteger) { 4941 babModel ->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");5514 babModel_->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts"); 4942 5515 switches[numberGenerators++]=1; 4943 5516 } 4944 5517 if (landpAction) { 4945 babModel ->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject");5518 babModel_->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject"); 4946 5519 switches[numberGenerators++]=1; 4947 5520 } 4948 5521 if (residualCapacityAction) { 4949 babModel ->addCutGenerator(&residualCapacityGen,translate[residualCapacityAction],"ResidualCapacity");5522 babModel_->addCutGenerator(&residualCapacityGen,translate[residualCapacityAction],"ResidualCapacity"); 4950 5523 switches[numberGenerators++]=1; 4951 5524 } 4952 5525 if (storedCuts) 4953 babModel ->setSpecialOptions(babModel->specialOptions()|64);5526 babModel_->setSpecialOptions(babModel_->specialOptions()|64); 4954 5527 // Say we want timings 4955 numberGenerators = babModel ->numberCutGenerators();5528 numberGenerators = babModel_->numberCutGenerators(); 4956 5529 int iGenerator; 4957 5530 int cutDepth= 4958 parameters [whichParam(CUTDEPTH,numberParameters,parameters)].intValue();5531 parameters_[whichParam(CUTDEPTH,numberParameters_,parameters_)].intValue(); 4959 5532 for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) { 4960 CbcCutGenerator * generator = babModel ->cutGenerator(iGenerator);5533 CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator); 4961 5534 int howOften = generator->howOften(); 4962 5535 if (howOften==-98||howOften==-99) … … 4968 5541 // Could tune more 4969 5542 if (!miplib) { 4970 babModel ->setMinimumDrop(min(5.0e-2,4971 fabs(babModel ->getMinimizationObjValue())*1.0e-3+1.0e-4));5543 babModel_->setMinimumDrop(min(5.0e-2, 5544 fabs(babModel_->getMinimizationObjValue())*1.0e-3+1.0e-4)); 4972 5545 if (cutPass==-1234567) { 4973 if (babModel ->getNumCols()<500)4974 babModel ->setMaximumCutPassesAtRoot(-100); // always do 100 if possible4975 else if (babModel ->getNumCols()<5000)4976 babModel ->setMaximumCutPassesAtRoot(100); // use minimum drop5546 if (babModel_->getNumCols()<500) 5547 babModel_->setMaximumCutPassesAtRoot(-100); // always do 100 if possible 5548 else if (babModel_->getNumCols()<5000) 5549 babModel_->setMaximumCutPassesAtRoot(100); // use minimum drop 4977 5550 else 4978 babModel ->setMaximumCutPassesAtRoot(20);5551 babModel_->setMaximumCutPassesAtRoot(20); 4979 5552 } else { 4980 babModel ->setMaximumCutPassesAtRoot(cutPass);5553 babModel_->setMaximumCutPassesAtRoot(cutPass); 4981 5554 } 4982 5555 if (cutPassInTree==-1234567) 4983 babModel ->setMaximumCutPasses(1);5556 babModel_->setMaximumCutPasses(1); 4984 5557 else 4985 babModel ->setMaximumCutPasses(cutPassInTree);5558 babModel_->setMaximumCutPasses(cutPassInTree); 4986 5559 } 4987 5560 // Do more strong branching if small 4988 //if (babModel ->getNumCols()<5000)4989 //babModel ->setNumberStrong(20);5561 //if (babModel_->getNumCols()<5000) 5562 //babModel_->setNumberStrong(20); 4990 5563 // Switch off strong branching if wanted 4991 //if (babModel ->getNumCols()>10*babModel->getNumRows())4992 //babModel ->setNumberStrong(0);4993 if (!noPrinting ) {4994 int iLevel = parameters [log].intValue();5564 //if (babModel_->getNumCols()>10*babModel_->getNumRows()) 5565 //babModel_->setNumberStrong(0); 5566 if (!noPrinting_) { 5567 int iLevel = parameters_[log].intValue(); 4995 5568 if (iLevel<0) { 4996 babModel ->setPrintingMode(1);5569 babModel_->setPrintingMode(1); 4997 5570 iLevel = -iLevel; 4998 5571 } 4999 babModel ->messageHandler()->setLogLevel(iLevel);5000 if (babModel ->getNumCols()>2000||babModel->getNumRows()>1500||5001 babModel ->messageHandler()->logLevel()>1)5002 babModel ->setPrintFrequency(100);5572 babModel_->messageHandler()->setLogLevel(iLevel); 5573 if (babModel_->getNumCols()>2000||babModel_->getNumRows()>1500|| 5574 babModel_->messageHandler()->logLevel()>1) 5575 babModel_->setPrintFrequency(100); 5003 5576 } 5004 5577 5005 babModel ->solver()->setIntParam(OsiMaxNumIterationHotStart,5006 parameters [whichParam(MAXHOTITS,numberParameters,parameters)].intValue());5007 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());5578 babModel_->solver()->setIntParam(OsiMaxNumIterationHotStart, 5579 parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].intValue()); 5580 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 5008 5581 // go faster stripes 5009 5582 if (osiclp->getNumRows()<300&&osiclp->getNumCols()<500) { 5010 osiclp->setupForRepeatedUse(2,parameters [slog].intValue());5583 osiclp->setupForRepeatedUse(2,parameters_[slog].intValue()); 5011 5584 } else { 5012 osiclp->setupForRepeatedUse(0,parameters [slog].intValue());5585 osiclp->setupForRepeatedUse(0,parameters_[slog].intValue()); 5013 5586 } 5014 double increment=babModel ->getCutoffIncrement();;5587 double increment=babModel_->getCutoffIncrement();; 5015 5588 int * changed = NULL; 5016 5589 if (!miplib&&increment==normalIncrement) 5017 5590 changed=analyze( osiclp,numberChanged,increment,false,generalMessageHandler); 5018 5591 if (debugValues) { 5019 if (numberDebugValues==babModel ->getNumCols()) {5592 if (numberDebugValues==babModel_->getNumCols()) { 5020 5593 // for debug 5021 babModel ->solver()->activateRowCutDebugger(debugValues) ;5594 babModel_->solver()->activateRowCutDebugger(debugValues) ; 5022 5595 } else { 5023 5596 printf("debug file has incorrect number of columns\n"); 5024 5597 } 5025 5598 } 5026 babModel ->setCutoffIncrement(CoinMax(babModel->getCutoffIncrement(),increment));5599 babModel_->setCutoffIncrement(CoinMax(babModel_->getCutoffIncrement(),increment)); 5027 5600 // Turn this off if you get problems 5028 5601 // Used to be automatically set 5029 int mipOptions = parameters [whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()%10000;5602 int mipOptions = parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].intValue()%10000; 5030 5603 if (mipOptions!=(1)) { 5031 5604 sprintf(generalPrint,"mip options %d",mipOptions); … … 5036 5609 osiclp->setSpecialOptions(mipOptions); 5037 5610 if (gapRatio < 1.0e100) { 5038 double value = babModel ->solver()->getObjValue() ;5611 double value = babModel_->solver()->getObjValue() ; 5039 5612 double value2 = gapRatio*(1.0e-5+fabs(value)) ; 5040 babModel ->setAllowableGap(value2) ;5613 babModel_->setAllowableGap(value2) ; 5041 5614 std::cout << "Continuous " << value 5042 5615 << ", so allowable gap set to " … … 5044 5617 } 5045 5618 // probably faster to use a basis to get integer solutions 5046 babModel ->setSpecialOptions(babModel->specialOptions()|2);5047 currentBranchModel = babModel ;5619 babModel_->setSpecialOptions(babModel_->specialOptions()|2); 5620 currentBranchModel = babModel_; 5048 5621 OsiSolverInterface * strengthenedModel=NULL; 5049 5622 if (type==BAB||type==MIPLIB) { 5050 int moreMipOptions = parameters [whichParam(MOREMIPOPTIONS,numberParameters,parameters)].intValue();5623 int moreMipOptions = parameters_[whichParam(MOREMIPOPTIONS,numberParameters_,parameters_)].intValue(); 5051 5624 if (moreMipOptions>=0) { 5052 5625 sprintf(generalPrint,"more mip options %d",moreMipOptions); … … 5054 5627 << generalPrint 5055 5628 <<CoinMessageEol; 5056 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());5629 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 5057 5630 if (moreMipOptions==10000) { 5058 5631 // test memory saving … … 5065 5638 } 5066 5639 if (((moreMipOptions+1)%1000000)!=0) 5067 babModel ->setSearchStrategy(moreMipOptions%1000000);5640 babModel_->setSearchStrategy(moreMipOptions%1000000); 5068 5641 // go faster stripes 5069 5642 if( moreMipOptions >=999999) { … … 5099 5672 if (solutionIn&&useSolution) { 5100 5673 if (preProcess) { 5101 int numberColumns = babModel ->getNumCols();5674 int numberColumns = babModel_->getNumCols(); 5102 5675 // extend arrays in case SOS 5103 5676 int n = originalColumns[numberColumns-1]+1; … … 5123 5696 prioritiesIn2[i]=prioritiesIn2[iColumn]; 5124 5697 } 5125 babModel ->setHotstartSolution(solutionIn2,prioritiesIn2);5698 babModel_->setHotstartSolution(solutionIn2,prioritiesIn2); 5126 5699 delete [] solutionIn2; 5127 5700 delete [] prioritiesIn2; 5128 5701 } else { 5129 babModel ->setHotstartSolution(solutionIn,prioritiesIn);5702 babModel_->setHotstartSolution(solutionIn,prioritiesIn); 5130 5703 } 5131 5704 } 5132 OsiSolverInterface * testOsiSolver= (testOsiOptions>=0) ? babModel ->solver() : NULL;5705 OsiSolverInterface * testOsiSolver= (testOsiOptions>=0) ? babModel_->solver() : NULL; 5133 5706 if (!testOsiSolver) { 5134 5707 // ************************************************************* 5135 5708 // CbcObjects 5136 if (preProcess&&(process.numberSOS()||babModel ->numberObjects())) {5709 if (preProcess&&(process.numberSOS()||babModel_->numberObjects())) { 5137 5710 int numberSOS = process.numberSOS(); 5138 int numberIntegers = babModel ->numberIntegers();5711 int numberIntegers = babModel_->numberIntegers(); 5139 5712 /* model may not have created objects 5140 5713 If none then create 5141 5714 */ 5142 if (!numberIntegers||!babModel ->numberObjects()) {5715 if (!numberIntegers||!babModel_->numberObjects()) { 5143 5716 int type = (pseudoUp) ? 1 : 0; 5144 babModel ->findIntegers(true,type);5145 numberIntegers = babModel ->numberIntegers();5717 babModel_->findIntegers(true,type); 5718 numberIntegers = babModel_->numberIntegers(); 5146 5719 integersOK=true; 5147 5720 } 5148 OsiObject ** oldObjects = babModel ->objects();5721 OsiObject ** oldObjects = babModel_->objects(); 5149 5722 // Do sets and priorities 5150 5723 OsiObject ** objects = new OsiObject * [numberSOS]; 5151 5724 // set old objects to have low priority 5152 int numberOldObjects = babModel ->numberObjects();5153 int numberColumns = babModel ->getNumCols();5725 int numberOldObjects = babModel_->numberObjects(); 5726 int numberColumns = babModel_->getNumCols(); 5154 5727 // backward pointer to new variables 5155 5728 int * newColumn = new int[numberOriginalColumns]; … … 5180 5753 } 5181 5754 } 5182 babModel ->setNumberObjects(n);5183 babModel ->zapIntegerInformation();5755 babModel_->setNumberObjects(n); 5756 babModel_->zapIntegerInformation(); 5184 5757 } 5185 5758 int nMissing=0; … … 5249 5822 int iStart = starts[iSOS]; 5250 5823 int n=starts[iSOS+1]-iStart; 5251 objects[iSOS] = new CbcSOS(babModel ,n,which+iStart,weight+iStart,5824 objects[iSOS] = new CbcSOS(babModel_,n,which+iStart,weight+iStart, 5252 5825 iSOS,type[iSOS]); 5253 5826 // branch on long sets first … … 5255 5828 } 5256 5829 if (numberSOS) 5257 babModel ->addObjects(numberSOS,objects);5830 babModel_->addObjects(numberSOS,objects); 5258 5831 for (iSOS=0;iSOS<numberSOS;iSOS++) 5259 5832 delete objects[iSOS]; … … 5261 5834 } else if (priorities||branchDirection||pseudoDown||pseudoUp||numberSOS) { 5262 5835 // do anyway for priorities etc 5263 int numberIntegers = babModel ->numberIntegers();5836 int numberIntegers = babModel_->numberIntegers(); 5264 5837 /* model may not have created objects 5265 5838 If none then create 5266 5839 */ 5267 if (!numberIntegers||!babModel ->numberObjects()) {5840 if (!numberIntegers||!babModel_->numberObjects()) { 5268 5841 int type = (pseudoUp) ? 1 : 0; 5269 babModel ->findIntegers(true,type);5842 babModel_->findIntegers(true,type); 5270 5843 } 5271 5844 if (numberSOS) { … … 5275 5848 if (originalColumns) { 5276 5849 // redo sequence numbers 5277 int numberColumns = babModel ->getNumCols();5850 int numberColumns = babModel_->getNumCols(); 5278 5851 int nOld = originalColumns[numberColumns-1]+1; 5279 5852 int * back = new int[nOld]; … … 5305 5878 int iStart = sosStart[iSOS]; 5306 5879 int n=sosStart[iSOS+1]-iStart; 5307 objects[iSOS] = new CbcSOS(babModel ,n,sosIndices+iStart,sosReference+iStart,5880 objects[iSOS] = new CbcSOS(babModel_,n,sosIndices+iStart,sosReference+iStart, 5308 5881 iSOS,sosType[iSOS]); 5309 5882 if (sosPriority) … … 5313 5886 } 5314 5887 // delete any existing SOS objects 5315 int numberObjects=babModel ->numberObjects();5316 OsiObject ** oldObjects=babModel ->objects();5888 int numberObjects=babModel_->numberObjects(); 5889 OsiObject ** oldObjects=babModel_->objects(); 5317 5890 int nNew=0; 5318 5891 for (int i=0;i<numberObjects;i++) { … … 5328 5901 } 5329 5902 } 5330 babModel ->setNumberObjects(nNew);5331 babModel ->addObjects(numberSOS,objects);5903 babModel_->setNumberObjects(nNew); 5904 babModel_->addObjects(numberSOS,objects); 5332 5905 for (iSOS=0;iSOS<numberSOS;iSOS++) 5333 5906 delete objects[iSOS]; … … 5335 5908 } 5336 5909 } 5337 OsiObject ** objects = babModel ->objects();5338 int numberObjects = babModel ->numberObjects();5910 OsiObject ** objects = babModel_->objects(); 5911 int numberObjects = babModel_->numberObjects(); 5339 5912 for (int iObj = 0;iObj<numberObjects;iObj++) { 5340 5913 // skip sos … … 5506 6079 OsiObject ** objects = testOsiSolver->objects(); 5507 6080 int numberObjects = testOsiSolver->numberObjects(); 5508 int logLevel = parameters [log].intValue();6081 int logLevel = parameters_[log].intValue(); 5509 6082 for (int iObj = 0;iObj<numberObjects;iObj++) { 5510 6083 // skip sos … … 5582 6155 // up or down 5583 6156 int way = (((nodeStrategy-1)%1)==1) ? -1 : +1; 5584 babModel ->setPreferredWay(way);6157 babModel_->setPreferredWay(way); 5585 6158 #if 0 5586 OsiObject ** objects = babModel ->objects();5587 int numberObjects = babModel ->numberObjects();6159 OsiObject ** objects = babModel_->objects(); 6160 int numberObjects = babModel_->numberObjects(); 5588 6161 for (int iObj = 0;iObj<numberObjects;iObj++) { 5589 6162 CbcObject * obj = … … 5598 6171 CbcCompareDefault compare; 5599 6172 compare.setWeight(-3.0); 5600 babModel ->setNodeComparison(compare);6173 babModel_->setNodeComparison(compare); 5601 6174 } else if (nodeStrategy==0) { 5602 6175 // hybrid was default i.e. mixture of low depth and infeasibility … … 5605 6178 CbcCompareDefault compare; 5606 6179 compare.setWeight(-2.0); 5607 babModel ->setNodeComparison(compare);6180 babModel_->setNodeComparison(compare); 5608 6181 } 5609 6182 } … … 5614 6187 if (fp) { 5615 6188 // generate enough to do BAB 5616 babModel ->generateCpp(fp,1);5617 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6189 babModel_->generateCpp(fp,1); 6190 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 5618 6191 // Make general so do factorization 5619 6192 int factor = osiclp->getModelPtr()->factorizationFrequency(); … … 5624 6197 fclose(fp); 5625 6198 // now call generate code 5626 generateCode(babModel ,"user_driver.cpp",cppValue,prepro);6199 generateCode(babModel_,"user_driver.cpp",cppValue,prepro); 5627 6200 } else { 5628 6201 std::cout<<"Unable to open file user_driver.cpp"<<std::endl; 5629 6202 } 5630 6203 } 5631 if (!babModel ->numberStrong())5632 babModel ->setNumberBeforeTrust(0);6204 if (!babModel_->numberStrong()) 6205 babModel_->setNumberBeforeTrust(0); 5633 6206 if (useStrategy) { 5634 CbcStrategyDefault strategy(true,babModel ->numberStrong(),babModel->numberBeforeTrust());6207 CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust()); 5635 6208 strategy.setupPreProcessing(1); 5636 babModel ->setStrategy(strategy);6209 babModel_->setStrategy(strategy); 5637 6210 } 5638 6211 if (testOsiOptions>=0) { … … 5642 6215 <<CoinMessageEol; 5643 6216 if (!numberSOS) { 5644 babModel ->solver()->findIntegersAndSOS(false);6217 babModel_->solver()->findIntegersAndSOS(false); 5645 6218 #ifdef COIN_HAS_LINK 5646 6219 // If linked then pass in model 5647 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel ->solver());6220 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver()); 5648 6221 if (solver3) { 5649 CbcHeuristicDynamic3 serendipity(*babModel );6222 CbcHeuristicDynamic3 serendipity(*babModel_); 5650 6223 serendipity.setHeuristicName("linked"); 5651 babModel ->addHeuristic(&serendipity);5652 double dextra3 = parameters [whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();6224 babModel_->addHeuristic(&serendipity); 6225 double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue(); 5653 6226 if (dextra3) 5654 6227 solver3->setMeshSizes(dextra3); 5655 int options = parameters [whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()/10000;6228 int options = parameters_[whichParam(MIPOPTIONS,numberParameters_,parameters_)].intValue()/10000; 5656 6229 CglStored stored; 5657 6230 if (options) { … … 5677 6250 solver3->sayConvex((options&32)==0); 5678 6251 } 5679 int extra1 = parameters [whichParam(EXTRA1,numberParameters,parameters)].intValue();6252 int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue(); 5680 6253 if ((options&1)!=0&&extra1>0) 5681 6254 solver3->setFixedPriority(extra1); … … 5683 6256 if ((options&8)) 5684 6257 cutoff=solver3->linearizedBAB(&stored); 5685 if (cutoff<babModel ->getCutoff()) {5686 babModel ->setCutoff(cutoff);6258 if (cutoff<babModel_->getCutoff()) { 6259 babModel_->setCutoff(cutoff); 5687 6260 // and solution 5688 //babModel ->setBestObjectiveValue(solver3->bestObjectiveValue());5689 babModel ->setBestSolution(solver3->bestSolution(),solver3->getNumCols(),6261 //babModel_->setBestObjectiveValue(solver3->bestObjectiveValue()); 6262 babModel_->setBestSolution(solver3->bestSolution(),solver3->getNumCols(), 5690 6263 solver3->bestObjectiveValue()); 5691 6264 } … … 5693 6266 solver3->setBranchingStrategyOnVariables(16,-1,4); 5694 6267 } 5695 solver3->setCbcModel(babModel );6268 solver3->setCbcModel(babModel_); 5696 6269 if (stored.sizeRowCuts()) 5697 babModel ->addCutGenerator(&stored,1,"Stored");6270 babModel_->addCutGenerator(&stored,1,"Stored"); 5698 6271 CglTemporary temp; 5699 babModel ->addCutGenerator(&temp,1,"OnceOnly");6272 babModel_->addCutGenerator(&temp,1,"OnceOnly"); 5700 6273 //choose.setNumberBeforeTrusted(2000); 5701 6274 //choose.setNumberStrong(20); 5702 6275 } 5703 6276 // For temporary testing of heuristics 5704 //int testOsiOptions = parameters [whichParam(TESTOSI,numberParameters,parameters)].intValue();6277 //int testOsiOptions = parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].intValue(); 5705 6278 if (testOsiOptions>=10) { 5706 6279 if (testOsiOptions>=20) 5707 6280 testOsiOptions -= 10; 5708 6281 printf("*** Temp heuristic with mode %d\n",testOsiOptions-10); 5709 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel ->solver());6282 OsiSolverLink * solver3 = dynamic_cast<OsiSolverLink *> (babModel_->solver()); 5710 6283 assert (solver3) ; 5711 int extra1 = parameters [whichParam(EXTRA1,numberParameters,parameters)].intValue();6284 int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue(); 5712 6285 solver3->setBiLinearPriority(extra1); 5713 6286 printf("bilinear priority now %d\n",extra1); 5714 int extra2 = parameters [whichParam(EXTRA2,numberParameters,parameters)].intValue();6287 int extra2 = parameters_[whichParam(EXTRA2,numberParameters_,parameters_)].intValue(); 5715 6288 double saveDefault = solver3->defaultBound(); 5716 6289 solver3->setDefaultBound((double) extra2); … … 5723 6296 } else { 5724 6297 // move across 5725 babModel ->deleteObjects(false);5726 //babModel ->addObjects(babModel->solver()->numberObjects(),babModel->solver()->objects());6298 babModel_->deleteObjects(false); 6299 //babModel_->addObjects(babModel_->solver()->numberObjects(),babModel_->solver()->objects()); 5727 6300 } 5728 6301 CbcBranchDefaultDecision decision; 5729 if (babModel ->numberStrong()) {5730 OsiChooseStrong choose(babModel ->solver());5731 choose.setNumberBeforeTrusted(babModel ->numberBeforeTrust());5732 choose.setNumberStrong(babModel ->numberStrong());6302 if (babModel_->numberStrong()) { 6303 OsiChooseStrong choose(babModel_->solver()); 6304 choose.setNumberBeforeTrusted(babModel_->numberBeforeTrust()); 6305 choose.setNumberStrong(babModel_->numberStrong()); 5733 6306 choose.setShadowPriceMode(testOsiOptions); 5734 6307 decision.setChooseMethod(choose); 5735 6308 } else { 5736 OsiChooseVariable choose(babModel ->solver());6309 OsiChooseVariable choose(babModel_->solver()); 5737 6310 decision.setChooseMethod(choose); 5738 6311 } 5739 babModel ->setBranchingMethod(decision);6312 babModel_->setBranchingMethod(decision); 5740 6313 if (useCosts&&testOsiOptions>=0) { 5741 int numberColumns = babModel ->getNumCols();6314 int numberColumns = babModel_->getNumCols(); 5742 6315 int * sort = new int[numberColumns]; 5743 6316 double * dsort = new double[numberColumns]; 5744 6317 int * priority = new int [numberColumns]; 5745 const double * objective = babModel ->getObjCoefficients();5746 const double * lower = babModel ->getColLower() ;5747 const double * upper = babModel ->getColUpper() ;5748 const CoinPackedMatrix * matrix = babModel ->solver()->getMatrixByCol();6318 const double * objective = babModel_->getObjCoefficients(); 6319 const double * lower = babModel_->getColLower() ; 6320 const double * upper = babModel_->getColUpper() ; 6321 const CoinPackedMatrix * matrix = babModel_->solver()->getMatrixByCol(); 5749 6322 const int * columnLength = matrix->getVectorLengths(); 5750 6323 int iColumn; … … 5773 6346 priority[iPut]=level; 5774 6347 } 5775 OsiObject ** objects = babModel ->objects();5776 int numberObjects = babModel ->numberObjects();6348 OsiObject ** objects = babModel_->objects(); 6349 int numberObjects = babModel_->numberObjects(); 5777 6350 for (int iObj = 0;iObj<numberObjects;iObj++) { 5778 6351 OsiObject * obj = objects[iObj] ; … … 5786 6359 } 5787 6360 } 5788 checkSOS(babModel , babModel->solver());6361 checkSOS(babModel_, babModel_->solver()); 5789 6362 if (doSprint>0) { 5790 6363 // Sprint for primal solves … … 5800 6373 // say use in OsiClp 5801 6374 clpSolve.setSpecialOption(6,1); 5802 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6375 OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 5803 6376 osiclp->setSolveOptions(clpSolve); 5804 6377 osiclp->setHintParam(OsiDoDualInResolve,false); … … 5811 6384 if (preProcess) { 5812 6385 const int * originalColumns = process.originalColumns(); 5813 int numberColumns = babModel ->getNumCols();6386 int numberColumns = babModel_->getNumCols(); 5814 6387 int * newColumn = new int[numberOriginalColumns]; 5815 6388 int i; … … 5862 6435 #endif 5863 6436 if (outputFormat==5) { 5864 osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6437 osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 5865 6438 lpSolver = osiclp->getModelPtr(); 5866 6439 lpSolver->setPersistenceFlag(1); … … 5869 6442 // add in lotsizing 5870 6443 if (usingAmpl&&info.special) { 5871 int numberColumns = babModel ->getNumCols();6444 int numberColumns = babModel_->getNumCols(); 5872 6445 int i; 5873 6446 int n=0; … … 5889 6462 int numberOldObjects=0; 5890 6463 OsiObject ** oldObjects=NULL; 5891 const double * lower = babModel ->solver()->getColLower();5892 const double * upper = babModel ->solver()->getColUpper();6464 const double * lower = babModel_->solver()->getColLower(); 6465 const double * upper = babModel_->solver()->getColUpper(); 5893 6466 if (testOsiOptions<0) { 5894 6467 // ************************************************************* 5895 6468 // CbcObjects 5896 numberIntegers = babModel ->numberIntegers();6469 numberIntegers = babModel_->numberIntegers(); 5897 6470 /* model may not have created objects 5898 6471 If none then create 5899 6472 */ 5900 if (!numberIntegers||!babModel ->numberObjects()) {6473 if (!numberIntegers||!babModel_->numberObjects()) { 5901 6474 int type = (pseudoUp) ? 1 : 0; 5902 babModel ->findIntegers(true,type);5903 numberIntegers = babModel ->numberIntegers();6475 babModel_->findIntegers(true,type); 6476 numberIntegers = babModel_->numberIntegers(); 5904 6477 } 5905 oldObjects = babModel ->objects();5906 numberOldObjects = babModel ->numberObjects();6478 oldObjects = babModel_->objects(); 6479 numberOldObjects = babModel_->numberObjects(); 5907 6480 } else { 5908 6481 numberIntegers = testOsiSolver->getNumIntegers(); … … 5929 6502 int priority = oldObjects[iObj]->priority(); 5930 6503 if (testOsiOptions<0) { 5931 objects[n] = new CbcLotsize(babModel ,iColumn,2,ranges,true);6504 objects[n] = new CbcLotsize(babModel_,iColumn,2,ranges,true); 5932 6505 } else { 5933 6506 objects[n] = new OsiLotsize(testOsiSolver,iColumn,2,ranges,true); … … 5938 6511 } 5939 6512 if (testOsiOptions<0) { 5940 babModel ->addObjects(n,objects);6513 babModel_->addObjects(n,objects); 5941 6514 } else { 5942 6515 testOsiSolver->addObjects(n,objects); … … 5949 6522 #endif 5950 6523 if (storedAmpl.sizeRowCuts()) { 5951 //babModel ->addCutGenerator(&storedAmpl,1,"AmplStored");6524 //babModel_->addCutGenerator(&storedAmpl,1,"AmplStored"); 5952 6525 int numberRowCuts = storedAmpl.sizeRowCuts(); 5953 6526 for (int i=0;i<numberRowCuts;i++) { 5954 6527 const OsiRowCut * rowCutPointer = storedAmpl.rowCutPointer(i); 5955 babModel ->makeGlobalCut(rowCutPointer);6528 babModel_->makeGlobalCut(rowCutPointer); 5956 6529 } 5957 6530 } 5958 6531 // If defaults then increase trust for small models 5959 6532 if (!strongChanged) { 5960 int numberColumns = babModel ->getNumCols();6533 int numberColumns = babModel_->getNumCols(); 5961 6534 if (numberColumns<=50) 5962 babModel ->setNumberBeforeTrust(1000);6535 babModel_->setNumberBeforeTrust(1000); 5963 6536 else if (numberColumns<=100) 5964 babModel ->setNumberBeforeTrust(100);6537 babModel_->setNumberBeforeTrust(100); 5965 6538 else if (numberColumns<=300) 5966 babModel ->setNumberBeforeTrust(50);6539 babModel_->setNumberBeforeTrust(50); 5967 6540 } 5968 6541 #ifdef CBC_THREAD 5969 int numberThreads =parameters[whichParam(THREADS,numberParameters,parameters)].intValue(); 5970 babModel->setNumberThreads(numberThreads%100); 5971 babModel->setThreadMode(numberThreads/100); 5972 #endif 5973 int returnCode=callBack(babModel,3); 6542 int numberThreads =parameters_[whichParam(THREADS,numberParameters_,parameters_)].intValue(); 6543 babModel_->setNumberThreads(numberThreads%100); 6544 babModel_->setThreadMode(numberThreads/100); 6545 #endif 6546 #ifdef NEW_STYLE_SOLVER 6547 int returnCode = callBack_->callBack(babModel_,3); 6548 #else 6549 int returnCode=callBack(babModel_,3); 6550 #endif 5974 6551 if (returnCode) { 5975 6552 // exit if user wants 5976 delete babModel; 6553 #ifdef NEW_STYLE_SOLVER 6554 updateModel(NULL,returnMode); 6555 #else 6556 delete babModel_; 6557 babModel_ = NULL; 6558 #endif 5977 6559 return returnCode; 5978 6560 } 5979 babModel->branchAndBound(statistics); 5980 returnCode=callBack(babModel,4); 6561 babModel_->branchAndBound(statistics); 6562 #ifdef NEW_STYLE_SOLVER 6563 returnCode = callBack_->callBack(babModel_,4); 6564 #else 6565 returnCode=callBack(babModel_,4); 6566 #endif 5981 6567 if (returnCode) { 5982 6568 // exit if user wants 5983 model.moveInfo(*babModel); 5984 delete babModel; 6569 #ifdef NEW_STYLE_SOLVER 6570 updateModel(NULL,returnMode); 6571 #else 6572 model_.moveInfo(*babModel_); 6573 delete babModel_; 6574 babModel_ = NULL; 6575 #endif 5985 6576 return returnCode; 5986 6577 } … … 5989 6580 malloc_stats2(); 5990 6581 #endif 5991 checkSOS(babModel , babModel->solver());6582 checkSOS(babModel_, babModel_->solver()); 5992 6583 } else if (type==MIPLIB) { 5993 CbcStrategyDefault strategy(true,babModel ->numberStrong(),babModel->numberBeforeTrust());6584 CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust()); 5994 6585 // Set up pre-processing 5995 6586 int translate2[]={9999,1,1,3,2,4,5}; 5996 6587 if (preProcess) 5997 6588 strategy.setupPreProcessing(translate2[preProcess]); 5998 babModel ->setStrategy(strategy);6589 babModel_->setStrategy(strategy); 5999 6590 #ifdef CBC_THREAD 6000 int numberThreads =parameters [whichParam(THREADS,numberParameters,parameters)].intValue();6001 babModel ->setNumberThreads(numberThreads%100);6002 babModel ->setThreadMode(numberThreads/100);6591 int numberThreads =parameters_[whichParam(THREADS,numberParameters_,parameters_)].intValue(); 6592 babModel_->setNumberThreads(numberThreads%100); 6593 babModel_->setThreadMode(numberThreads/100); 6003 6594 #endif 6004 6595 if (outputFormat==5) { 6005 osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6596 osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 6006 6597 lpSolver = osiclp->getModelPtr(); 6007 6598 lpSolver->setPersistenceFlag(1); … … 6010 6601 printf("Testing OsiObject options %d\n",testOsiOptions); 6011 6602 CbcBranchDefaultDecision decision; 6012 OsiChooseStrong choose(babModel ->solver());6013 choose.setNumberBeforeTrusted(babModel ->numberBeforeTrust());6014 choose.setNumberStrong(babModel ->numberStrong());6603 OsiChooseStrong choose(babModel_->solver()); 6604 choose.setNumberBeforeTrusted(babModel_->numberBeforeTrust()); 6605 choose.setNumberStrong(babModel_->numberStrong()); 6015 6606 choose.setShadowPriceMode(testOsiOptions); 6016 //babModel ->deleteObjects(false);6607 //babModel_->deleteObjects(false); 6017 6608 decision.setChooseMethod(choose); 6018 babModel ->setBranchingMethod(decision);6609 babModel_->setBranchingMethod(decision); 6019 6610 } 6020 model = *babModel;6611 model_ = *babModel_; 6021 6612 /* LL: this was done in CoinSolve.cpp: main(argc, argv). 6022 6613 I have moved it here so that the miplib directory location 6023 6614 could be passed to CbcClpUnitTest. */ 6024 if (call_CbcClpUnitTest_on_777 == 777) { 6025 CbcClpUnitTest(model, dirMiplib, false); 6026 } 6615 /* JJF: No need to have 777 flag at all - user 6616 says -miplib 6617 */ 6618 CbcClpUnitTest(model_, dirMiplib, false); 6027 6619 return 777; 6028 6620 } else { 6029 strengthenedModel = babModel ->strengthenedModel();6621 strengthenedModel = babModel_->strengthenedModel(); 6030 6622 } 6031 6623 currentBranchModel = NULL; 6032 osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6033 if (debugFile=="createAfterPre"&&babModel ->bestSolution()) {6624 osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 6625 if (debugFile=="createAfterPre"&&babModel_->bestSolution()) { 6034 6626 lpSolver = osiclp->getModelPtr(); 6035 6627 //move best solution (should be there -- but ..) 6036 6628 int n = lpSolver->getNumCols(); 6037 memcpy(lpSolver->primalColumnSolution(),babModel ->bestSolution(),n*sizeof(double));6629 memcpy(lpSolver->primalColumnSolution(),babModel_->bestSolution(),n*sizeof(double)); 6038 6630 saveSolution(osiclp->getModelPtr(),"debug.file"); 6039 6631 } 6040 if (!noPrinting ) {6632 if (!noPrinting_) { 6041 6633 // Print more statistics 6042 6634 sprintf(generalPrint,"Cuts at root node changed objective from %g to %g", 6043 babModel ->getContinuousObjective(),babModel->rootObjectiveAfterCuts());6635 babModel_->getContinuousObjective(),babModel_->rootObjectiveAfterCuts()); 6044 6636 generalMessageHandler->message(CLP_GENERAL,generalMessages) 6045 6637 << generalPrint 6046 6638 <<CoinMessageEol; 6047 6639 6048 numberGenerators = babModel ->numberCutGenerators();6640 numberGenerators = babModel_->numberCutGenerators(); 6049 6641 char timing[30]; 6050 6642 for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) { 6051 CbcCutGenerator * generator = babModel ->cutGenerator(iGenerator);6643 CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator); 6052 6644 sprintf(generalPrint,"%s was tried %d times and created %d cuts of which %d were active after adding rounds of cuts", 6053 6645 generator->cutGeneratorName(), … … 6069 6661 // For best solution 6070 6662 double * bestSolution = NULL; 6071 if (babModel ->getMinimizationObjValue()<1.0e50&&type==BAB) {6663 if (babModel_->getMinimizationObjValue()<1.0e50&&type==BAB) { 6072 6664 // post process 6073 6665 int n; … … 6075 6667 n = saveSolver->getNumCols(); 6076 6668 bestSolution = new double [n]; 6077 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6669 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 6078 6670 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 6079 6671 lpSolver->setSpecialOptions(lpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound) 6080 process.postProcess(*babModel ->solver());6672 process.postProcess(*babModel_->solver()); 6081 6673 // Solution now back in saveSolver 6082 babModel ->assignSolver(saveSolver);6083 memcpy(bestSolution,babModel ->solver()->getColSolution(),n*sizeof(double));6674 babModel_->assignSolver(saveSolver); 6675 memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double)); 6084 6676 } else { 6085 n = babModel ->solver()->getNumCols();6677 n = babModel_->solver()->getNumCols(); 6086 6678 bestSolution = new double [n]; 6087 memcpy(bestSolution,babModel ->solver()->getColSolution(),n*sizeof(double));6679 memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double)); 6088 6680 } 6089 model.setBestSolution(bestSolution,n,babModel->getObjValue()); 6681 #ifndef NEW_STYLE_SOLVER 6682 if (returnMode==1) 6683 model_.setBestSolution(bestSolution,n,babModel_->getObjValue()); 6684 #endif 6685 babModel_->setBestSolution(bestSolution,n,babModel_->getObjValue()); 6686 #ifndef NEW_STYLE_SOLVER 6090 6687 // and put back in very original solver 6091 6688 { … … 6095 6692 double * solution = original->primalColumnSolution(); 6096 6693 int n = original->numberColumns(); 6097 //assert (!n||n==babModel ->solver()->getNumCols());6694 //assert (!n||n==babModel_->solver()->getNumCols()); 6098 6695 for (int i=0;i<n;i++) { 6099 6696 solution[i]=bestSolution[i]; … … 6104 6701 } 6105 6702 // basis 6106 CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel ->solver()->getWarmStart());6703 CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel_->solver()->getWarmStart()); 6107 6704 originalSolver->setBasis(*basis); 6108 6705 delete basis; 6109 6706 } 6110 checkSOS(babModel, babModel->solver()); 6111 } else if (model.bestSolution()&&type==BAB&&model.getMinimizationObjValue()&&preProcess) { 6112 sprintf(generalPrint,"Restoring heuristic best solution of %g",model.getMinimizationObjValue()); 6707 #endif 6708 checkSOS(babModel_, babModel_->solver()); 6709 } else if (model_.bestSolution()&&type==BAB&&model_.getMinimizationObjValue()<1.0e50&&preProcess) { 6710 sprintf(generalPrint,"Restoring heuristic best solution of %g",model_.getMinimizationObjValue()); 6113 6711 generalMessageHandler->message(CLP_GENERAL,generalMessages) 6114 6712 << generalPrint … … 6117 6715 bestSolution = new double [n]; 6118 6716 // Put solution now back in saveSolver 6119 babModel->assignSolver(saveSolver); 6120 saveSolver->setColSolution(model.bestSolution()); 6121 memcpy(bestSolution,babModel->solver()->getColSolution(),n*sizeof(double)); 6717 babModel_->assignSolver(saveSolver); 6718 saveSolver->setColSolution(model_.bestSolution()); 6719 memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double)); 6720 #ifndef NEW_STYLE_SOLVER 6122 6721 // and put back in very original solver 6123 6722 { … … 6127 6726 double * solution = original->primalColumnSolution(); 6128 6727 int n = original->numberColumns(); 6129 //assert (!n||n==babModel ->solver()->getNumCols());6728 //assert (!n||n==babModel_->solver()->getNumCols()); 6130 6729 for (int i=0;i<n;i++) { 6131 6730 solution[i]=bestSolution[i]; … … 6136 6735 } 6137 6736 // basis 6138 CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel ->solver()->getWarmStart());6737 CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (babModel_->solver()->getWarmStart()); 6139 6738 originalSolver->setBasis(*basis); 6140 6739 delete basis; 6141 6740 } 6741 #endif 6142 6742 } 6143 6743 if (type==STRENGTHEN&&strengthenedModel) … … 6145 6745 #ifdef COIN_HAS_ASL 6146 6746 else if (usingAmpl) 6147 clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6747 clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 6148 6748 #endif 6149 6749 lpSolver = clpSolver->getModelPtr(); … … 6165 6765 memset (rowSolution,0,numberRows*sizeof(double)); 6166 6766 lpSolver->clpMatrix()->times(1.0,bestSolution,rowSolution); 6167 lpSolver->setObjectiveValue(babModel ->getObjValue());6767 lpSolver->setObjectiveValue(babModel_->getObjValue()); 6168 6768 } 6169 6769 if (debugFile=="create"&&bestSolution) { … … 6174 6774 "","","User ctrl-c"}; 6175 6775 std::string minor[]={"","","gap","nodes","time","","solutions","user ctrl-c"}; 6176 int iStat = babModel ->status();6177 int iStat2 = babModel ->secondaryStatus();6178 if (!noPrinting ) {6776 int iStat = babModel_->status(); 6777 int iStat2 = babModel_->secondaryStatus(); 6778 if (!noPrinting_) { 6179 6779 sprintf(generalPrint,"Result - %s%s objective %.16g after %d nodes and %d iterations - took %.2f seconds (total time %.2f)", 6180 6780 statusName[iStat].c_str(),minor[iStat2].c_str(), 6181 babModel ->getObjValue(),babModel->getNodeCount(),6182 babModel ->getIterationCount(),time2-time1,time2-time0);6781 babModel_->getObjValue(),babModel_->getNodeCount(), 6782 babModel_->getIterationCount(),time2-time1,time2-time0); 6183 6783 generalMessageHandler->message(CLP_GENERAL,generalMessages) 6184 6784 << generalPrint 6185 6785 <<CoinMessageEol; 6186 6786 } 6187 int returnCode=callBack(babModel,5); 6787 #ifdef NEW_STYLE_SOLVER 6788 int returnCode = callBack_->callBack(babModel_,5); 6789 #else 6790 int returnCode=callBack(babModel_,5); 6791 #endif 6188 6792 if (returnCode) { 6189 6793 // exit if user wants 6190 model.moveInfo(*babModel); 6191 delete babModel; 6794 #ifdef NEW_STYLE_SOLVER 6795 updateModel(NULL,returnMode); 6796 #else 6797 model_.moveInfo(*babModel_); 6798 delete babModel_; 6799 babModel_ = NULL; 6800 #endif 6192 6801 return returnCode; 6193 6802 } 6194 6803 #ifdef COIN_HAS_ASL 6195 6804 if (usingAmpl) { 6196 clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel ->solver());6805 clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver()); 6197 6806 lpSolver = clpSolver->getModelPtr(); 6198 double value = babModel ->getObjValue()*lpSolver->getObjSense();6807 double value = babModel_->getObjValue()*lpSolver->getObjSense(); 6199 6808 char buf[300]; 6200 6809 int pos=0; 6201 6810 if (iStat==0) { 6202 if (babModel ->getObjValue()<1.0e40) {6811 if (babModel_->getObjValue()<1.0e40) { 6203 6812 pos += sprintf(buf+pos,"optimal," ); 6204 6813 } else { … … 6225 6834 info.problemStatus=iStat; 6226 6835 info.objValue = value; 6227 if (babModel ->getObjValue()<1.0e40) {6836 if (babModel_->getObjValue()<1.0e40) { 6228 6837 int precision = ampl_obj_prec(); 6229 6838 if (precision>0) … … 6234 6843 } 6235 6844 sprintf(buf+pos,"\n%d nodes, %d iterations, %g seconds", 6236 babModel ->getNodeCount(),6237 babModel ->getIterationCount(),6845 babModel_->getNodeCount(), 6846 babModel_->getIterationCount(), 6238 6847 totalTime); 6239 6848 if (bestSolution) { … … 6272 6881 if (usingAmpl) { 6273 6882 // keep if going to be destroyed 6274 OsiSolverInterface * solver = babModel ->solver();6883 OsiSolverInterface * solver = babModel_->solver(); 6275 6884 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver); 6276 6885 ClpSimplex * lpSolver2 = clpSolver->getModelPtr(); 6277 6886 if (lpSolver==lpSolver2) 6278 babModel ->setModelOwnsSolver(false);6887 babModel_->setModelOwnsSolver(false); 6279 6888 } 6280 6889 #endif 6281 //delete babModel ;6282 //babModel =NULL;6890 //delete babModel_; 6891 //babModel_=NULL; 6283 6892 } else { 6284 6893 #ifndef DISALLOW_PRINTING … … 6319 6928 } 6320 6929 #endif 6321 //delete babModel ;6322 //babModel =NULL;6930 //delete babModel_; 6931 //babModel_=NULL; 6323 6932 // get next field 6324 6933 field = CoinReadGetString(argc,argv); 6325 6934 if (field=="$") { 6326 field = parameters [iParam].stringValue();6935 field = parameters_[iParam].stringValue(); 6327 6936 } else if (field=="EOL") { 6328 parameters [iParam].printString();6937 parameters_[iParam].printString(); 6329 6938 break; 6330 6939 } else { 6331 parameters [iParam].setStringValue(field);6940 parameters_[iParam].setStringValue(field); 6332 6941 } 6333 6942 std::string fileName; … … 6464 7073 field = CoinReadGetString(argc,argv); 6465 7074 if (field=="$") { 6466 field = parameters [iParam].stringValue();7075 field = parameters_[iParam].stringValue(); 6467 7076 } else if (field=="EOL") { 6468 parameters [iParam].printString();7077 parameters_[iParam].printString(); 6469 7078 break; 6470 7079 } else { 6471 parameters [iParam].setStringValue(field);7080 parameters_[iParam].setStringValue(field); 6472 7081 } 6473 7082 std::string fileName; … … 6517 7126 OsiSolverLink solver1; 6518 7127 OsiSolverInterface * solver2 = solver1.clone(); 6519 model .assignSolver(solver2,false);7128 model_.assignSolver(solver2,false); 6520 7129 OsiSolverLink * si = 6521 dynamic_cast<OsiSolverLink *>(model .solver()) ;7130 dynamic_cast<OsiSolverLink *>(model_.solver()) ; 6522 7131 assert (si != NULL); 6523 7132 si->setDefaultMeshSize(0.001); 6524 7133 // need some relative granularity 6525 7134 si->setDefaultBound(100.0); 6526 double dextra3 = parameters [whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();7135 double dextra3 = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue(); 6527 7136 if (dextra3) 6528 7137 si->setDefaultMeshSize(dextra3); … … 6533 7142 si->load(*model2); 6534 7143 // redo 6535 solver = model .solver();7144 solver = model_.solver(); 6536 7145 clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver); 6537 7146 lpSolver = clpSolver->getModelPtr(); … … 6548 7157 field = CoinReadGetString(argc,argv); 6549 7158 if (field=="$") { 6550 field = parameters [iParam].stringValue();7159 field = parameters_[iParam].stringValue(); 6551 7160 } else if (field=="EOL") { 6552 parameters [iParam].printString();7161 parameters_[iParam].printString(); 6553 7162 break; 6554 7163 } else { 6555 parameters [iParam].setStringValue(field);7164 parameters_[iParam].setStringValue(field); 6556 7165 } 6557 7166 std::string fileName; … … 6611 7220 pinfo.statistics(); 6612 7221 double presolveTolerance = 6613 parameters [whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();7222 parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].doubleValue(); 6614 7223 model2 = 6615 7224 pinfo.presolvedModel(*lpSolver,presolveTolerance, … … 6691 7300 field = CoinReadGetString(argc,argv); 6692 7301 if (field=="$") { 6693 field = parameters [iParam].stringValue();7302 field = parameters_[iParam].stringValue(); 6694 7303 } else if (field=="EOL") { 6695 parameters [iParam].printString();7304 parameters_[iParam].printString(); 6696 7305 break; 6697 7306 } else { 6698 parameters [iParam].setStringValue(field);7307 parameters_[iParam].setStringValue(field); 6699 7308 } 6700 7309 std::string fileName; … … 6748 7357 field = CoinReadGetString(argc,argv); 6749 7358 if (field=="$") { 6750 field = parameters [iParam].stringValue();7359 field = parameters_[iParam].stringValue(); 6751 7360 } else if (field=="EOL") { 6752 parameters [iParam].printString();7361 parameters_[iParam].printString(); 6753 7362 break; 6754 7363 } else { 6755 parameters [iParam].setStringValue(field);7364 parameters_[iParam].setStringValue(field); 6756 7365 } 6757 7366 std::string fileName; … … 6986 7595 } 6987 7596 } 6988 if (!noPrinting ) {7597 if (!noPrinting_) { 6989 7598 printf("%d fields and %d records",nAcross,nLine); 6990 7599 if (nBadPseudo) … … 7023 7632 field = CoinReadGetString(argc,argv); 7024 7633 if (field=="$") { 7025 field = parameters [iParam].stringValue();7634 field = parameters_[iParam].stringValue(); 7026 7635 } else if (field=="EOL") { 7027 parameters [iParam].printString();7636 parameters_[iParam].printString(); 7028 7637 break; 7029 7638 } else { 7030 parameters [iParam].setStringValue(field);7639 parameters_[iParam].setStringValue(field); 7031 7640 debugFile=field; 7032 7641 if (debugFile=="create"|| … … 7079 7688 std::string name = CoinReadGetString(argc,argv); 7080 7689 if (name!="EOL") { 7081 parameters [iParam].setStringValue(name);7690 parameters_[iParam].setStringValue(name); 7082 7691 printMask = name; 7083 7692 } else { 7084 parameters [iParam].printString();7693 parameters_[iParam].printString(); 7085 7694 } 7086 7695 } … … 7091 7700 field = CoinReadGetString(argc,argv); 7092 7701 if (field=="$") { 7093 field = parameters [iParam].stringValue();7702 field = parameters_[iParam].stringValue(); 7094 7703 } else if (field=="EOL") { 7095 parameters [iParam].printString();7704 parameters_[iParam].printString(); 7096 7705 break; 7097 7706 } else { 7098 parameters [iParam].setStringValue(field);7707 parameters_[iParam].setStringValue(field); 7099 7708 } 7100 7709 std::string fileName; … … 7140 7749 field = CoinReadGetString(argc,argv); 7141 7750 if (field=="$") { 7142 field = parameters [iParam].stringValue();7751 field = parameters_[iParam].stringValue(); 7143 7752 } else if (field=="EOL") { 7144 parameters [iParam].printString();7753 parameters_[iParam].printString(); 7145 7754 break; 7146 7755 } else { 7147 parameters [iParam].setStringValue(field);7756 parameters_[iParam].setStringValue(field); 7148 7757 } 7149 7758 std::string fileName; … … 7179 7788 ClpPresolve pinfo; 7180 7789 double presolveTolerance = 7181 parameters [whichParam(PRESOLVETOLERANCE,numberParameters,parameters)].doubleValue();7790 parameters_[whichParam(PRESOLVETOLERANCE,numberParameters_,parameters_)].doubleValue(); 7182 7791 model2 = 7183 7792 pinfo.presolvedModel(*lpSolver,presolveTolerance, … … 7218 7827 field = CoinReadGetString(argc,argv); 7219 7828 if (field=="$") { 7220 field = parameters [iParam].stringValue();7829 field = parameters_[iParam].stringValue(); 7221 7830 } else if (field=="EOL") { 7222 parameters [iParam].printString();7831 parameters_[iParam].printString(); 7223 7832 break; 7224 7833 } else { 7225 parameters [iParam].setStringValue(field);7834 parameters_[iParam].setStringValue(field); 7226 7835 } 7227 7836 std::string fileName; … … 7304 7913 directory = name+dirsep; 7305 7914 } 7306 parameters [iParam].setStringValue(directory);7915 parameters_[iParam].setStringValue(directory); 7307 7916 } else { 7308 parameters [iParam].printString();7917 parameters_[iParam].printString(); 7309 7918 } 7310 7919 } … … 7320 7929 dirSample = name+dirsep; 7321 7930 } 7322 parameters [iParam].setStringValue(dirSample);7931 parameters_[iParam].setStringValue(dirSample); 7323 7932 } else { 7324 parameters [iParam].printString();7933 parameters_[iParam].printString(); 7325 7934 } 7326 7935 } … … 7336 7945 dirNetlib = name+dirsep; 7337 7946 } 7338 parameters [iParam].setStringValue(dirNetlib);7947 parameters_[iParam].setStringValue(dirNetlib); 7339 7948 } else { 7340 parameters [iParam].printString();7949 parameters_[iParam].printString(); 7341 7950 } 7342 7951 } … … 7352 7961 dirMiplib = name+dirsep; 7353 7962 } 7354 parameters [iParam].setStringValue(dirMiplib);7963 parameters_[iParam].setStringValue(dirMiplib); 7355 7964 } else { 7356 parameters [iParam].printString();7965 parameters_[iParam].printString(); 7357 7966 } 7358 7967 } … … 7373 7982 case UNITTEST: 7374 7983 { 7375 CbcClpUnitTest(model , dirSample, true);7984 CbcClpUnitTest(model_, dirSample, true); 7376 7985 } 7377 7986 break; … … 7381 7990 double value = CoinReadGetDoubleField(argc,argv,&valid); 7382 7991 if (!valid) { 7383 std::cout<<"Setting "<<parameters [iParam].name()<<7992 std::cout<<"Setting "<<parameters_[iParam].name()<< 7384 7993 " to DEBUG "<<value<<std::endl; 7385 7994 int iRow; … … 7409 8018 abort(); 7410 8019 } else { 7411 std::cout<<"enter value for "<<parameters [iParam].name()<<8020 std::cout<<"enter value for "<<parameters_[iParam].name()<< 7412 8021 std::endl; 7413 8022 } … … 7427 8036 if (goodModel) { 7428 8037 // Way of using an existing piece of code 7429 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model .solver());8038 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver()); 7430 8039 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 7431 8040 // set time from integer model 7432 double timeToGo = model .getMaximumSeconds();8041 double timeToGo = model_.getMaximumSeconds(); 7433 8042 lpSolver->setMaximumSeconds(timeToGo); 7434 int extra1 = parameters [whichParam(EXTRA1,numberParameters,parameters)].intValue();8043 int extra1 = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue(); 7435 8044 fakeMain2(*lpSolver,*clpSolver,extra1); 7436 8045 lpSolver = clpSolver->getModelPtr(); … … 7443 8052 } 7444 8053 #endif 8054 #ifdef NEW_STYLE_SOLVER 8055 if (goodModel) { 8056 std::string name = CoinReadGetString(argc,argv); 8057 if (name!="EOL") { 8058 int length = name.size(); 8059 int percent = name.find('%'); 8060 std::string command = name; 8061 std::string options = ""; 8062 if (percent<length&&percent>0) { 8063 command = name.substr(0,percent); 8064 options = name.substr(percent+1); 8065 } 8066 CbcUser * userCode = userFunction(command.c_str()); 8067 if (userCode) 8068 userCode->solve(this,options.c_str()); 8069 } else { 8070 parameters_[iParam].printString(); 8071 } 8072 } 8073 #endif 7445 8074 break; 7446 8075 case USERCBC: … … 7449 8078 if (goodModel) { 7450 8079 // Way of using an existing piece of code 7451 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model .solver());8080 OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver()); 7452 8081 ClpSimplex * lpSolver = clpSolver->getModelPtr(); 7453 8082 // set time from integer model 7454 double timeToGo = model .getMaximumSeconds();8083 double timeToGo = model_.getMaximumSeconds(); 7455 8084 lpSolver->setMaximumSeconds(timeToGo); 7456 8085 fakeMain(*lpSolver,*clpSolver,model); … … 7462 8091 #endif 7463 8092 // make sure solution back in correct place 7464 clpSolver = dynamic_cast< OsiClpSolverInterface*> (model .solver());8093 clpSolver = dynamic_cast< OsiClpSolverInterface*> (model_.solver()); 7465 8094 lpSolver = clpSolver->getModelPtr(); 7466 8095 #ifdef COIN_HAS_ASL … … 7501 8130 value); 7502 8131 sprintf(buf+pos,"\n%d nodes, %d iterations", 7503 model .getNodeCount(),7504 model .getIterationCount());8132 model_.getNodeCount(), 8133 model_.getIterationCount()); 7505 8134 if (objectiveValue<1.0e50) { 7506 8135 free(info.primalSolution); … … 7544 8173 field = CoinReadGetString(argc,argv); 7545 8174 if (field=="$") { 7546 field = parameters [iParam].stringValue();8175 field = parameters_[iParam].stringValue(); 7547 8176 } else if (field=="EOL") { 7548 parameters [iParam].printString();8177 parameters_[iParam].printString(); 7549 8178 break; 7550 8179 } else { 7551 parameters [iParam].setStringValue(field);8180 parameters_[iParam].setStringValue(field); 7552 8181 } 7553 8182 std::string fileName; … … 7754 8383 fprintf(fp,"\tint intIndicesV[]={\n"); 7755 8384 for (iColumn=0;iColumn<numberColumns;iColumn++) { 7756 if(primalColumnSolution[iColumn]>0.5&&model .solver()->isInteger(iColumn)) {8385 if(primalColumnSolution[iColumn]>0.5&&model_.solver()->isInteger(iColumn)) { 7757 8386 if (comma) 7758 8387 fprintf(fp,","); … … 7775 8404 fprintf(fp,"\tdouble intSolnV[]={\n"); 7776 8405 for ( iColumn=0;iColumn<numberColumns;iColumn++) { 7777 if(primalColumnSolution[iColumn]>0.5&&model .solver()->isInteger(iColumn)) {8406 if(primalColumnSolution[iColumn]>0.5&&model_.solver()->isInteger(iColumn)) { 7778 8407 if (comma) 7779 8408 fprintf(fp,","); … … 7815 8444 field = CoinReadGetString(argc,argv); 7816 8445 if (field=="$") { 7817 field = parameters [iParam].stringValue();8446 field = parameters_[iParam].stringValue(); 7818 8447 } else if (field=="EOL") { 7819 parameters [iParam].printString();8448 parameters_[iParam].printString(); 7820 8449 break; 7821 8450 } else { 7822 parameters [iParam].setStringValue(field);8451 parameters_[iParam].setStringValue(field); 7823 8452 } 7824 8453 std::string fileName; … … 7856 8485 if (!numberQuery) { 7857 8486 std::cout<<"Short match for "<<field<<" - completion: "; 7858 std::cout<<parameters [firstMatch].matchName()<<std::endl;8487 std::cout<<parameters_[firstMatch].matchName()<<std::endl; 7859 8488 } else if (numberQuery) { 7860 std::cout<<parameters [firstMatch].matchName()<<" : ";7861 std::cout<<parameters [firstMatch].shortHelp()<<std::endl;8489 std::cout<<parameters_[firstMatch].matchName()<<" : "; 8490 std::cout<<parameters_[firstMatch].shortHelp()<<std::endl; 7862 8491 if (numberQuery>=2) 7863 parameters [firstMatch].printLongHelp();8492 parameters_[firstMatch].printLongHelp(); 7864 8493 } 7865 8494 } else { … … 7869 8498 else 7870 8499 std::cout<<"Completions of "<<field<<":"<<std::endl; 7871 for ( iParam=0; iParam<numberParameters ; iParam++ ) {7872 int match = parameters [iParam].matches(field);7873 if (match&¶meters [iParam].displayThis()) {7874 std::cout<<parameters [iParam].matchName();8500 for ( iParam=0; iParam<numberParameters_; iParam++ ) { 8501 int match = parameters_[iParam].matches(field); 8502 if (match&¶meters_[iParam].displayThis()) { 8503 std::cout<<parameters_[iParam].matchName(); 7875 8504 if (numberQuery>=2) 7876 std::cout<<" : "<<parameters [iParam].shortHelp();8505 std::cout<<" : "<<parameters_[iParam].shortHelp(); 7877 8506 std::cout<<std::endl; 7878 8507 } … … 7886 8515 //dmalloc_shutdown(); 7887 8516 #endif 7888 if (babModel) { 7889 model.moveInfo(*babModel); 7890 //babModel->setModelOwnsSolver(false); 8517 #ifdef NEW_STYLE_SOLVER 8518 updateModel(NULL,returnMode); 8519 sprintf(generalPrint,"Total time %.2f",CoinCpuTime()-startTime_); 8520 #else 8521 if (babModel_) { 8522 model_.moveInfo(*babModel_); 8523 //babModel_->setModelOwnsSolver(false); 7891 8524 } 7892 8525 #ifdef CBC_SIG_TRAP … … 7895 8528 // register signal handler 7896 8529 saveSignal=signal(SIGSEGV,signal_handler_error); 7897 // to force failure!babModel ->setNumberObjects(20000);8530 // to force failure!babModel_->setNumberObjects(20000); 7898 8531 if (!sigsetjmp(cbc_seg_buffer,1)) { 7899 8532 #endif 7900 delete babModel ;8533 delete babModel_; 7901 8534 #ifdef CBC_SIG_TRAP 7902 8535 } else { 7903 std::cerr<<"delete babModel failed"<<std::endl;8536 std::cerr<<"delete babModel_ failed"<<std::endl; 7904 8537 } 7905 #endif 7906 model.solver()->setWarmStart(NULL); 8538 #endif 8539 babModel_ = NULL; 8540 model_.solver()->setWarmStart(NULL); 7907 8541 sprintf(generalPrint,"Total time %.2f",CoinCpuTime()-time0); 8542 #endif 7908 8543 generalMessageHandler->message(CLP_GENERAL,generalMessages) 7909 8544 << generalPrint -
trunk/Cbc/src/CoinSolve.cpp
r765 r779 5 5 #include "CoinPragma.hpp" 6 6 #include "CbcModel.hpp" 7 #include "CbcOrClpParam.hpp" 7 8 #include "OsiClpSolverInterface.hpp" 8 9 … … 13 14 #include <cstring> 14 15 #include <iostream> 16 //#define NEW_STYLE_SOLVER 17 #ifndef NEW_STYLE_SOLVER 15 18 // define TEST_MESSAGE_HANDLER to check works on all messages 16 19 //#define TEST_MESSAGE_HANDLER … … 215 218 setCbcOrClpPrinting(false); 216 219 #endif 217 int returnCode = CbcMain1 (argc, argv,model , 777);220 int returnCode = CbcMain1 (argc, argv,model); 218 221 #if 0 219 222 /* The call to CbcClpUnitTest was moved into CbcMain1. To make sure … … 239 242 #endif 240 243 } 241 244 #else 245 #include "CbcSolver.hpp" 246 int main (int argc, const char *argv[]) 247 { 248 OsiClpSolverInterface solver1; 249 CbcSolver control(solver1); 250 // initialize 251 control.fillValuesInSolver(); 252 return control.solve (argc, argv, 2); 253 } 254 #endif 242 255 /* 243 256 Version 1.00.00 November 16 2005.
Note: See TracChangeset
for help on using the changeset viewer.