Changeset 738


Ignore:
Timestamp:
Aug 10, 2007 7:52:05 AM (12 years ago)
Author:
forrest
Message:

to make easier to use as function

Location:
trunk/Cbc/src
Files:
5 edited

Legend:

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

    r723 r738  
    1515#include "CbcBranchActual.hpp"
    1616#include "CoinHelperFunctions.hpp"
     17#include "CoinWarmStartBasis.hpp"
    1718#include "CoinTime.hpp"
    1819
     
    271272  int totalNumberPasses=0;
    272273  int numberTries=0;
     274  CoinWarmStartBasis bestBasis;
    273275  while (true) {
    274276    int numberPasses=0;
     
    412414            }
    413415          }
    414           if (returnCode) {
     416          if (returnCode&&newSolutionValue<saveValue) {
    415417            memcpy(betterSolution,newSolution,numberColumns*sizeof(double));
     418            CoinWarmStartBasis * basis =
     419              dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
     420            if (basis) {
     421              bestBasis = * basis;
     422              delete basis;
     423            }
    416424            if ((accumulate_&1)!=0)
    417425              model_->incrementUsed(betterSolution); // for local search
     
    426434            pumpPrint[0]='\0';
    427435          } else {
    428             sprintf(pumpPrint+strlen(pumpPrint)," - not good enough after mini branch and bound");
     436            sprintf(pumpPrint+strlen(pumpPrint)," - not improved by mini branch and bound");
    429437            model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    430438              << pumpPrint
     
    555563            if (newSolutionValue<solutionValue) {
    556564              memcpy(betterSolution,newSolution,numberColumns*sizeof(double));
     565              CoinWarmStartBasis * basis =
     566                dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
     567              if (basis) {
     568                bestBasis = * basis;
     569                delete basis;
     570              }
    557571              if ((accumulate_&1)!=0)
    558572                model_->incrementUsed(betterSolution); // for local search
     
    768782        returnCode &= ~2;
    769783      }
    770       if (returnCode) {
     784      if (returnCode&&newSolutionValue<saveValue) {
    771785        sprintf(pumpPrint+strlen(pumpPrint),"Mini branch and bound improved solution from %g to %g (%.2f seconds)",
    772786                saveValue,newSolutionValue,model_->getCurrentSeconds());
     
    810824        solutionValue=newSolutionValue;
    811825        solutionFound=true;
     826        CoinWarmStartBasis * basis =
     827          dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart()) ;
     828        if (basis) {
     829          bestBasis = * basis;
     830          delete basis;
     831        }
    812832      } else {
    813833        sprintf(pumpPrint+strlen(pumpPrint),"Mini branch and bound did not improve solution (%.2f seconds)",
     
    890910    << pumpPrint
    891911    <<CoinMessageEol;
     912  if (bestBasis.getNumStructural())
     913    model_->setBestSolutionBasis(bestBasis);
    892914  return finalReturnCode;
    893915}
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r708 r738  
    547547        // new solution
    548548        memcpy(betterSolution,newSolution,numberColumns*sizeof(double));
     549        CoinWarmStartBasis * basis =
     550          dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
     551        if (basis) {
     552          model_->setBestSolutionBasis(* basis);
     553          delete basis;
     554        }
    549555        returnCode=1;
    550556        solutionValue = newSolutionValue + bestChange;
  • trunk/Cbc/src/CbcModel.cpp

    r724 r738  
    22612261      pthread_cond_signal(threadInfo[i].condition2); // unlock
    22622262      //if (!stopped)
    2263         pthread_join(threadId[i],NULL);
     2263      //pthread_join(threadId[i],NULL);
     2264      int returnCode;
     2265      returnCode=pthread_join(threadId[i],NULL);
     2266      assert (!returnCode);
    22642267        //else
    22652268        //pthread_kill(threadId[i]); // kill rather than try and synchronize
     
    30883091{
    30893092  // resize best solution if exists
    3090   if (bestSolution_) {
     3093  if (bestSolution_&&solver&&solver_) {
    30913094    int nOld = solver_->getNumCols();
    30923095    int nNew = solver->getNumCols();
     
    31133116  { delete emptyWarmStart_  ;
    31143117    emptyWarmStart_ = 0 ; }
     3118  bestSolutionBasis_ = CoinWarmStartBasis();
    31153119/*
    31163120  Initialize integer variable vector.
     
    33893393    addedCuts_ = NULL;
    33903394  }
     3395  bestSolutionBasis_ = rhs.bestSolutionBasis_;
    33913396  nextRowCut_ = NULL;
    33923397  currentNode_ = NULL;
     
    36503655      addedCuts_ = NULL;
    36513656    }
     3657    bestSolutionBasis_ = rhs.bestSolutionBasis_;
    36523658    nextRowCut_ = NULL;
    36533659    currentNode_ = NULL;
     
    49074913            // add to global list
    49084914            OsiRowCut newCut(*thisCut);
    4909             newCut.setGloballyValid(2);
     4915            newCut.setGloballyValid(true);
    49104916            newCut.mutableRow().setTestForDuplicateIndex(false);
    49114917            globalCuts_.insert(newCut) ;
     
    49274933              // add to global list
    49284934              OsiRowCut newCut(*thisCut);
    4929               newCut.setGloballyValid(2);
     4935              newCut.setGloballyValid(true);
    49304936              newCut.mutableRow().setTestForDuplicateIndex(false);
    49314937              globalCuts_.insert(newCut) ;
     
    49394945            // add to global list
    49404946            OsiColCut newCut(*thisCut);
    4941             newCut.setGloballyValid(2);
     4947            newCut.setGloballyValid(true);
    49424948            globalCuts_.insert(newCut) ;
    49434949          }
     
    51625168            // add to global list
    51635169            OsiRowCut newCut(*thisCut);
    5164             newCut.setGloballyValid(2);
     5170            newCut.setGloballyValid(true);
    51655171            newCut.mutableRow().setTestForDuplicateIndex(false);
    51665172            globalCuts_.insert(newCut) ;
     
    51735179            // add to global list
    51745180            OsiColCut newCut(*thisCut);
    5175             newCut.setGloballyValid(2);
     5181            newCut.setGloballyValid(true);
    51765182            globalCuts_.insert(newCut) ;
    51775183          }
     
    53475353*/
    53485354    int numberRowsNow = solver_->getNumRows() ;
     5355#ifndef NDEBUG
    53495356    assert(numberRowsNow == numberRowsAtStart+lastNumberCuts) ;
     5357#else
     5358    // ? maybe clue to threaded problems
     5359    if(numberRowsNow != numberRowsAtStart+lastNumberCuts) {
     5360      fprintf(stderr,"*** threaded error - numberRowsNow(%d) != numberRowsAtStart(%d)+lastNumberCuts(%d)\n",
     5361              numberRowsNow,numberRowsAtStart,lastNumberCuts);
     5362      fprintf(stdout,"*** threaded error - numberRowsNow(%d) != numberRowsAtStart(%d)+lastNumberCuts(%d)\n",
     5363              numberRowsNow,numberRowsAtStart,lastNumberCuts);
     5364      abort();
     5365    }
     5366#endif
    53505367    int numberToAdd = theseCuts.sizeRowCuts() ;
    53515368    numberNewCuts_ = lastNumberCuts+numberToAdd ;
     
    73277344        solver_->setWarmStart(slack);
    73287345        delete slack ;
     7346      } else {
     7347        if (bestSolutionBasis_.getNumStructural()==solver_->getNumCols()&&
     7348            bestSolutionBasis_.getNumArtificial()==solver_->getNumRows())
     7349          solver_->setWarmStart(&bestSolutionBasis_);
    73297350      }
    73307351      // Give a hint to do dual
     
    73787399      objectiveValue = solver_->getObjValue()*solver_->getObjSense();
    73797400    }
     7401    bestSolutionBasis_ = CoinWarmStartBasis();
    73807402   
    73817403    /*
     
    75277549                        // add to global list
    75287550                        OsiRowCut newCut(*thisCut);
    7529                         newCut.setGloballyValid(2);
     7551                        newCut.setGloballyValid(true);
    75307552                        newCut.mutableRow().setTestForDuplicateIndex(false);
    75317553                        globalCuts_.insert(newCut) ;
     
    77047726              // add to global list
    77057727              OsiRowCut newCut(*thisCut);
    7706               newCut.setGloballyValid(2);
     7728              newCut.setGloballyValid(true);
    77077729              newCut.mutableRow().setTestForDuplicateIndex(false);
    77087730              globalCuts_.insert(newCut) ;
     
    77187740          // add to global list
    77197741          OsiColCut newCut(*thisCut);
    7720           newCut.setGloballyValid(2);
     7742          newCut.setGloballyValid(true);
    77217743          globalCuts_.insert(newCut) ;
    77227744        }
     
    92039225        int start = rowStart[iRow];
    92049226        thisCut.setRow(rowLength[iRow],column+start,elementByRow+start,false);
    9205         thisCut.setGloballyValid(2);
     9227        thisCut.setGloballyValid(true);
    92069228        globalCuts_.insert(thisCut) ;
    92079229      }
     
    92269248{
    92279249  OsiRowCut newCut(cut);
    9228   newCut.setGloballyValid(2);
     9250  newCut.setGloballyValid(true);
    92299251  newCut.mutableRow().setTestForDuplicateIndex(false);
    92309252  globalCuts_.insert(newCut) ;
  • trunk/Cbc/src/CbcModel.hpp

    r715 r738  
    16591659  /// Generate an OsiBranchingInformation object
    16601660  OsiBranchingInformation usefulInformation() const;
     1661  /** Warm start object produced by heuristic or strong branching
     1662
     1663      If get a valid integer solution outside branch and bound then it can take
     1664      a reasonable time to solve LP which produces clean solution.  If this object has
     1665      any size then it will be used in solve.
     1666  */
     1667  inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis)
     1668  { bestSolutionBasis_ = bestSolutionBasis;}
    16611669  //@}
    16621670
     
    17341742  */
    17351743  mutable const double * testSolution_;
     1744  /** Warm start object produced by heuristic or strong branching
     1745
     1746      If get a valid integer solution outside branch and bound then it can take
     1747      a reasonable time to solve LP which produces clean solution.  If this object has
     1748      any size then it will be used in solve.
     1749  */
     1750  CoinWarmStartBasis bestSolutionBasis_ ;
    17361751  /// Global cuts
    17371752  OsiCuts globalCuts_;
     
    20672082int callCbc1(const char * input2, CbcModel & babSolver);
    20682083int callCbc1(const std::string input2, CbcModel & babSolver);
     2084// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
     2085int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
     2086int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
     2087int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    20692088#endif
  • trunk/Cbc/src/CbcSolver.cpp

    r725 r738  
    8282}
    8383#endif
     84//#define DMALLOC
    8485#ifdef DMALLOC
    8586#include "dmalloc.h"
     
    170171   }
    171172}
     173//#define CBC_SIG_TRAP
     174#ifdef CBC_SIG_TRAP
     175#include <setjmp.h>
     176static sigjmp_buf cbc_seg_buffer;
     177extern "C" {
     178   static void signal_handler_error(int whichSignal)
     179   {
     180     siglongjmp(cbc_seg_buffer,1);
     181   }
     182}
     183#endif
    172184
    173185int CbcOrClpRead_mode=1;
     
    11801192#endif
    11811193}
    1182 int callCbc1(const char * input2, CbcModel & model)
     1194int callCbc1(const char * input2, CbcModel & model, int callBack(CbcModel * currentSolver, int whereFrom))
    11831195{
    11841196  char * input = strdup(input2);
     
    12311243  CbcOrClpReadCommand=stdin;
    12321244  noPrinting=false;
    1233   int returnCode = CbcMain1(n+2,const_cast<const char **>(argv),model);
     1245  int returnCode = CbcMain1(n+2,const_cast<const char **>(argv),model,callBack);
    12341246  for (int k=0;k<n+2;k++)
    12351247    free(argv[k]);
     
    12841296  return returnCode;
    12851297}
    1286 
     1298static int dummyCallBack(CbcModel * model, int whereFrom)
     1299{
     1300  return 0;
     1301}
     1302int CbcMain1 (int argc, const char *argv[],
     1303             CbcModel  & model)
     1304{
     1305  return CbcMain1(argc,argv,model,dummyCallBack);
     1306}
     1307int callCbc1(const std::string input2, CbcModel & babSolver, int callBack(CbcModel * currentSolver, int whereFrom))
     1308{
     1309  char * input3 = strdup(input2.c_str());
     1310  int returnCode=callCbc1(input3,babSolver,callBack);
     1311  free(input3);
     1312  return returnCode;
     1313}
     1314int callCbc1(const char * input2, CbcModel & model)
     1315{
     1316  return callCbc1(input2,model,dummyCallBack);
     1317}
    12871318int CbcMain (int argc, const char *argv[],
    12881319             CbcModel  & model)
     
    14021433  parameters[whichParam(COSTSTRATEGY,numberParameters,parameters)].setCurrentOption("off");
    14031434}
     1435/* Meaning of whereFrom:
     1436   1 after initial solve by dualsimplex etc
     1437   2 after preprocessing
     1438   3 just before branchAndBound (so user can override)
     1439   4 just after branchAndBound (before postprocessing)
     1440   5 after postprocessing
     1441*/
    14041442int CbcMain1 (int argc, const char *argv[],
    1405              CbcModel  & model)
     1443             CbcModel  & model, int callBack(CbcModel * currentSolver, int whereFrom))
    14061444{
    14071445  /* Note
     
    26222660                  babModel->setProblemStatus(iStatus);
    26232661                  babModel->setSecondaryStatus(iStatus2);
     2662                }
     2663                int returnCode=callBack(&model,1);
     2664                if (returnCode) {
     2665                  // exit if user wants
     2666                  delete babModel;
     2667                  return returnCode;
    26242668                }
    26252669              }
     
    30383082                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
    30393083                ClpSimplex * clpSolver = si->getModelPtr();
     3084                int iStatus = clpSolver->status();
     3085                int iStatus2 = clpSolver->secondaryStatus();
     3086                if (iStatus==0) {
     3087                  iStatus2=0;
     3088                } else if (iStatus==1) {
     3089                  iStatus=0;
     3090                  iStatus2=1; // say infeasible
     3091                } else if (iStatus==2) {
     3092                  iStatus=0;
     3093                  iStatus2=7; // say unbounded
     3094                } else if (iStatus==3) {
     3095                  iStatus=1;
     3096                  if (iStatus2==9)
     3097                    iStatus2=4;
     3098                  else
     3099                    iStatus2=3; // Use nodes - as closer than solutions
     3100                } else if (iStatus==4) {
     3101                  iStatus=2; // difficulties
     3102                  iStatus2=0;
     3103                }
     3104                model.setProblemStatus(iStatus);
     3105                model.setSecondaryStatus(iStatus2);
     3106                si->setWarmStart(NULL);
     3107                int returnCode=callBack(&model,1);
     3108                if (returnCode) {
     3109                  // exit if user wants
     3110                  delete babModel;
     3111                  return returnCode;
     3112                }
    30403113                clpSolver->setSpecialOptions(clpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound)
    30413114                if (!noPrinting) {
     
    33533426                      << generalPrint
    33543427                      <<CoinMessageEol;
    3355                     break;
    33563428                  } else {
    33573429                    //printf("processed model has %d rows, %d columns and %d elements\n",
    33583430                    //     solver2->getNumRows(),solver2->getNumCols(),solver2->getNumElements());
    33593431                  }
    3360                 }
     3432                }
     3433                if (!solver2) {
     3434                  model.setProblemStatus(0);
     3435                  model.setSecondaryStatus(1);
     3436                  babModel->setProblemStatus(0);
     3437                  babModel->setSecondaryStatus(1);
     3438                } else {
     3439                  model.setProblemStatus(-1);
     3440                  babModel->setProblemStatus(-1);
     3441                }
     3442                int returnCode=callBack(babModel,2);
     3443                if (returnCode) {
     3444                  // exit if user wants
     3445                  delete babModel;
     3446                  return returnCode;
     3447                }
     3448                if (!solver2)
     3449                  break;
    33613450                //solver2->resolve();
    33623451                if (preProcess==2) {
     
    46914780                babModel->setThreadMode(numberThreads/100);
    46924781#endif
     4782                int returnCode=callBack(babModel,3);
     4783                if (returnCode) {
     4784                  // exit if user wants
     4785                  delete babModel;
     4786                  return returnCode;
     4787                }
    46934788                babModel->branchAndBound(statistics);
     4789                returnCode=callBack(babModel,4);
     4790                if (returnCode) {
     4791                  // exit if user wants
     4792                  model.moveInfo(*babModel);
     4793                  delete babModel;
     4794                  return returnCode;
     4795                }
    46944796#ifdef CLP_MALLOC_STATISTICS
    46954797                malloc_stats();
     
    48504952                    << generalPrint
    48514953                    <<CoinMessageEol;
     4954                }
     4955                int returnCode=callBack(babModel,5);
     4956                if (returnCode) {
     4957                  // exit if user wants
     4958                  model.moveInfo(*babModel);
     4959                  delete babModel;
     4960                  return returnCode;
    48524961                }
    48534962#ifdef COIN_HAS_ASL
     
    64786587  // By now all memory should be freed
    64796588#ifdef DMALLOC
    6480   dmalloc_log_unfreed();
    6481   dmalloc_shutdown();
     6589  //dmalloc_log_unfreed();
     6590  //dmalloc_shutdown();
    64826591#endif
    6483   if (babModel)
     6592  if (babModel) {
    64846593    model.moveInfo(*babModel);
    6485   delete babModel;
     6594    //babModel->setModelOwnsSolver(false);
     6595  }
     6596#ifdef CBC_SIG_TRAP
     6597  // On Sun sometimes seems to be error - try and get round it
     6598  CoinSighandler_t saveSignal=SIG_DFL;
     6599  // register signal handler
     6600  saveSignal=signal(SIGSEGV,signal_handler_error);
     6601  // to force failure!babModel->setNumberObjects(20000);
     6602  if (!sigsetjmp(cbc_seg_buffer,1)) {
     6603#endif
     6604    delete babModel;
     6605#ifdef CBC_SIG_TRAP
     6606  } else {
     6607    std::cerr<<"delete babModel failed"<<std::endl;
     6608  }
     6609  #endif
    64866610  model.solver()->setWarmStart(NULL);
    64876611  return 0;
Note: See TracChangeset for help on using the changeset viewer.