Changeset 539 for branches


Ignore:
Timestamp:
Feb 16, 2007 5:17:39 PM (13 years ago)
Author:
forrest
Message:

for nonlinear

Location:
branches/devel/Cbc/src
Files:
10 edited

Legend:

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

    r523 r539  
    233233  }
    234234  if (n2<numberMembers_) {
    235     printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
     235    //printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
    236236    numberMembers_=n2;
    237237  }
     
    550550  }
    551551  if (n2<numberMembers_) {
    552     printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
     552    //printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
    553553    numberMembers_=n2;
    554554  }
  • branches/devel/Cbc/src/CbcHeuristic.cpp

    r522 r539  
    107107#ifdef COIN_HAS_CLP
    108108  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (solver);
    109   if (osiclp) {
     109  if (osiclp&&(osiclp->specialOptions()&1024)==0) {
    110110    // go faster stripes
    111111    if (osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
  • branches/devel/Cbc/src/CbcLinked.cpp

    r529 r539  
    63576357          }
    63586358          break;
    6359         }
     6359        } else if (typeRun==1&&numberOutput==maxNumber) {
     6360          // On second run
     6361          for (i=0;i<numJ;i++) {
     6362            bound[i]=0;
     6363          }
     6364          break;
     6365        }
    63606366        for (int j=0;j<numJ;j++) {
    63616367          checkSize += stack[j]*size[j];
  • branches/devel/Cbc/src/CbcMessage.cpp

    r439 r539  
    7373    message ++;
    7474  }
     75  // Put into compact form
     76  toCompact();
    7577
    7678  // now override any language ones
  • branches/devel/Cbc/src/CbcModel.cpp

    r534 r539  
    1313//#define CHECK_NODE_FULL
    1414//#define NODE_LOG
    15 //#define GLOBAL_CUTS_JUST_POINTERS
     15#define GLOBAL_CUTS_JUST_POINTERS
    1616#include <cassert>
    1717#include <cmath>
     
    554554          } else if (isInteger(iColumn)) {
    555555            object_[numberIntegers_] =
    556               new CbcSimpleInteger(this,numberIntegers_,iColumn);
     556              new CbcSimpleInteger(this,iColumn);
    557557            integerVariable_[numberIntegers_++]=iColumn;
    558558          }
     
    889889     Could use last parameter for subtle differences */
    890890  solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
    891 /*
    892   Create a copy of the solver, thus capturing the original (root node)
    893   constraint system (aka the continuous system).
    894 */
    895   continuousSolver_ = solver_->clone() ;
    896891#ifdef COIN_HAS_CLP
    897892 {
     
    899894     = dynamic_cast<OsiClpSolverInterface *> (solver_);
    900895   if (clpSolver) {
     896     // Try and re-use regions
     897     clpSolver->getModelPtr()->setPersistenceFlag(1);
    901898     if ((specialOptions_&32)==0) {
    902899       ClpSimplex * clpSimplex = clpSolver->getModelPtr();
     
    911908 }
    912909#endif
     910/*
     911  Create a copy of the solver, thus capturing the original (root node)
     912  constraint system (aka the continuous system).
     913*/
     914  continuousSolver_ = solver_->clone() ;
    913915
    914916  numberRowsAtContinuous_ = getNumRows() ;
     
    46974699              cuts.insert(globalCuts_.rowCut(i)) ;
    46984700#else
    4699               cuts.insert(globalCuts_.rowCutPtr(i)) ;
     4701              OsiRowCut * rowCutPointer = globalCuts_.rowCutPtr(i);
     4702              cuts.insert(rowCutPointer) ;
    47004703#endif
    47014704            }
     
    50585061      }
    50595062    }
    5060   } else if (numberCutGenerators_) {
    5061     int i;
    5062     // add to counts anyway
    5063     for (i = 0;i<numberCutGenerators_;i++)
    5064       generator_[i]->incrementNumberCutsInTotal(countRowCuts[i]);
    5065     // What if not feasible as cuts may have helped
    5066     if (feasible) {
    5067       for (i = 0;i<numberNewCuts_;i++) {
    5068         int iGenerator = whichGenerator_[i];
    5069         if (iGenerator>=0)
    5070           generator_[iGenerator]->incrementNumberCutsActive();
     5063  } else {
     5064#ifdef COIN_HAS_CLP
     5065    OsiClpSolverInterface * clpSolver
     5066      = dynamic_cast<OsiClpSolverInterface *> (solver_);
     5067    if (clpSolver) {
     5068      // Maybe solver might like to know only column bounds will change
     5069      //int options = clpSolver->specialOptions();
     5070      //clpSolver->setSpecialOptions(options|128);
     5071      clpSolver->synchronizeModel();
     5072    }
     5073#endif
     5074    if (numberCutGenerators_) {
     5075      int i;
     5076      // add to counts anyway
     5077      for (i = 0;i<numberCutGenerators_;i++)
     5078        generator_[i]->incrementNumberCutsInTotal(countRowCuts[i]);
     5079      // What if not feasible as cuts may have helped
     5080      if (feasible) {
     5081        for (i = 0;i<numberNewCuts_;i++) {
     5082          int iGenerator = whichGenerator_[i];
     5083          if (iGenerator>=0)
     5084            generator_[iGenerator]->incrementNumberCutsActive();
     5085        }
    50715086      }
    50725087    }
     
    59896004      else if (type==1)
    59906005        object_[numberIntegers_] =
    5991           new CbcSimpleIntegerPseudoCost(this,numberIntegers_,iColumn,0.3);
     6006          new CbcSimpleIntegerPseudoCost(this,iColumn,0.3);
    59926007      integerVariable_[numberIntegers_++]=iColumn;
    59936008    }
     
    82248239{
    82258240  OsiRowCut newCut(*cut);
    8226   newCut.setGloballyValid(2);
     8241  newCut.setGloballyValidAsInteger(2);
    82278242  newCut.mutableRow().setTestForDuplicateIndex(false);
    82288243  globalCuts_.insert(newCut) ;
     
    87988813      } else if (isInteger(iColumn)) {
    87998814        object_[numberIntegers_] =
    8800           new CbcSimpleInteger(this,numberIntegers_,iColumn);
     8815          new CbcSimpleInteger(this,iColumn);
    88018816        integerVariable_[numberIntegers_++]=iColumn;
    88028817      }
  • branches/devel/Cbc/src/CbcModel.hpp

    r529 r539  
    13381338  {return handler_;};
    13391339  /// Return messages
    1340   inline CoinMessages messages()
     1340  inline CoinMessages & messages()
    13411341  {return messages_;};
    13421342  /// Return pointer to messages
  • branches/devel/Cbc/src/CbcNode.cpp

    r529 r539  
    13311331          clp->primal(1);
    13321332          if (clp->numberIterations())
    1333             model->messageHandler()->message(CBC_ITERATE_STRONG,model->messages())
     1333            model->messageHandler()->message(CBC_ITERATE_STRONG,*model->messagesPointer())
    13341334              << clp->numberIterations()
    13351335              <<CoinMessageEol;
     
    18371837        for (i = 0 ; i < numberStrong ; i++) {
    18381838          int iColumn = choice[i].possibleBranch->variable() ;
    1839           model->messageHandler()->message(CBC_STRONG,model->messages())
     1839          model->messageHandler()->message(CBC_STRONG,*model->messagesPointer())
    18401840            << i << iColumn
    18411841            <<choice[i].downMovement<<choice[i].numIntInfeasDown
     
    31543154                printf("sort %g downest %g upest %g ",sort[iDo],downEstimate[iObject],
    31553155                     upEstimate[iObject]);
    3156               model->messageHandler()->message(CBC_STRONG,model->messages())
     3156              model->messageHandler()->message(CBC_STRONG,*model->messagesPointer())
    31573157                << iObject << iColumn
    31583158                <<choice.downMovement<<choice.numIntInfeasDown
     
    33583358        solveAll=false;
    33593359      if (model->messageHandler()->logLevel()>3||false) {
    3360         if (anyAction==-2)
     3360        if (anyAction==-2) {
    33613361          printf("infeasible\n");
    3362         else if(anyAction==-1)
     3362        } else if(anyAction==-1) {
    33633363          if (!solveAll)
    33643364            printf("%d fixed\n",numberToFix);
     
    33663366            printf("%d fixed AND choosing %d iDo %d iChosenWhen %d numberToDo %d\n",numberToFix,bestChoice,
    33673367                   iDo,whichChoice,numberToDo);
    3368         else
    3369           printf("choosing %d iDo %d iChosenWhen %d numberToDo %d\n",bestChoice,
     3368        } else {
     3369          printf("choosing %d  iDo %d iChosenWhen %d numberToDo %d\n",bestChoice,
    33703370                 iDo,whichChoice,numberToDo);
     3371        }
    33713372      }
    33723373      if (doneHotStart) {
     
    38513852        choice.downMovement = CoinMax(0.0,choice.downMovement);
    38523853        // feasible -
    3853         model->messageHandler()->message(CBC_STRONG,model->messages())
     3854        model->messageHandler()->message(CBC_STRONG,*model->messagesPointer())
    38543855          << iObject << iColumn
    38553856          <<choice.downMovement<<choice.numIntInfeasDown
  • branches/devel/Cbc/src/CbcStrategy.cpp

    r477 r539  
    353353        OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    354354        ClpSimplex * lpSolver = clpSolver->getModelPtr();
     355        lpSolver->passInMessageHandler(solver->messageHandler());
    355356        if (lpSolver->tightenPrimalBounds()==0) {
    356357          lpSolver->dual();
  • branches/devel/Cbc/src/Cbc_C_Interface.h

    r486 r539  
    109109  /** Fills in array with problem name  */
    110110  COINLIBAPI void COINLINKAGE Cbc_problemName(Cbc_Model * model, int maxNumberCharacters, char * array);
    111   /** Sets problem name.  Must have \0 at end.  */
     111  /** Sets problem name.  Must have NULL at end.  */
    112112  COINLIBAPI int COINLINKAGE
    113113  Cbc_setProblemName(Cbc_Model * model, int maxNumberCharacters, char * array);
  • branches/devel/Cbc/src/CoinSolve.cpp

    r531 r539  
    3838#include "OsiRowCutDebugger.hpp"
    3939#include "OsiChooseVariable.hpp"
    40 //#define CLP_MALLOC_STATISTICS
     40#define CLP_MALLOC_STATISTICS
    4141#ifdef CLP_MALLOC_STATISTICS
    4242#include <exception>
     
    4747static int malloc_n=10;
    4848double malloc_counts[10]={0,0,0,0,0,0,0,0,0,0};
    49 void * operator new (size_t size)
     49void * operator new (size_t size) throw (std::bad_alloc)
    5050{
    5151  malloc_times ++;
     
    6161  return p;
    6262}
    63 void operator delete (void *p)
     63void operator delete (void *p) throw()
    6464{
    6565  free(p);
    6666}
    67 static voif malloc_stats()
     67static void malloc_stats2()
    6868{
    6969  double average = malloc_total/malloc_times;
     
    7272    printf("%g ",malloc_counts[i]);
    7373  printf("\n");
     74  malloc_times=0.0;
     75  malloc_total=0.0;
     76  memset(malloc_counts,0,sizeof(malloc_counts));
    7477}
    7578#endif
     
    469472               int * knapsackRow, int &numberKnapsack,
    470473               CglStored & stored, int logLevel,
    471                int fixedPriority)
     474               int fixedPriority, int SOSPriority)
    472475{
    473476  int maxTotal = numberKnapsack;
     
    486489  const int * priorities=model.priorities();
    487490  int numberColumns = model.numberColumns();
    488   int SOSPriority=10000;
    489491  if (priorities) {
    490492    OsiObject ** objects = si->objects();
     
    503505    if (fixedPriority>0) {
    504506      si->setFixedPriority(fixedPriority);
    505       SOSPriority=fixedPriority+1;
    506507    }
     508    if (SOSPriority<0)
     509      SOSPriority=100000;
    507510  }
    508511  CoinModel coinModel=*si->coinModel();
     
    844847        int * buildStart = new int[nLargest+1];
    845848        int * buildRow = new int[nelLargest];
    846         OsiObject ** object = new OsiObject * [numberKnapsack];
     849        // alow for integers in knapsacks
     850        OsiObject ** object = new OsiObject * [numberKnapsack+nTotal];
    847851        int nSOS=0;
     852        int nObj=numberKnapsack;
    848853        for (iKnapsack=0;iKnapsack<numberKnapsack;iKnapsack++) {
    849854          knapsackStart[iKnapsack]=finalModel->getNumCols();
     
    870875              finalModel->setInteger(iColumn);
    871876            }
     877            OsiSimpleInteger * sosObject = new OsiSimpleInteger(finalModel,iColumn);
     878            sosObject->setPriority(1000000);
     879            object[nObj++]=sosObject;
    872880            buildRow[iColumn-numberOther]=iColumn;
    873881            buildElement[iColumn-numberOther]=1.0;
     
    880888            int n=numberFinal-numberOther;
    881889            buildRow[n]=iColumn;
    882             buildElement[n++]=coefficient[iKnapsack];
     890            buildElement[n++]=-fabs(coefficient[iKnapsack]);
    883891            // convexity row (sort of)
    884892            finalModel->addRow(n,buildRow,buildElement,0.0,0.0);
     
    891899          numberOther=numberFinal;
    892900        }
    893         finalModel->addObjects(nSOS,object);
    894         for (iKnapsack=0;iKnapsack<nSOS;iKnapsack++)
     901        finalModel->addObjects(nObj,object);
     902        for (iKnapsack=0;iKnapsack<nObj;iKnapsack++)
    895903          delete object[iKnapsack];
    896904        delete [] object;
    897905        // Can we move any rows to cuts
    898906        const int * cutMarker = coinModel.cutMarker();
     907        if (cutMarker&&0) {
     908          printf("AMPL CUTS OFF until global cuts fixed\n");
     909          cutMarker=NULL;
     910        }
    899911        if (cutMarker) {
    900912          // Row copy
     
    12431255                          info.rowLower,info.rowUpper);
    12441256      // take off cuts if ampl wants that
     1257      if (info.cut&&0) {
     1258        printf("AMPL CUTS OFF until global cuts fixed\n");
     1259        info.cut=NULL;
     1260      }
    12451261      if (info.cut) {
    12461262        int numberRows = info.numberRows;
     
    27762792                      knapsackRow=new int[numberRows];
    27772793                      numberKnapsack=10000;
     2794                      int extra1 = parameters[whichParam(EXTRA1,numberParameters,parameters)].intValue();
     2795                      int extra2 = parameters[whichParam(EXTRA2,numberParameters,parameters)].intValue();
     2796                      int logLevel = parameters[log].intValue();
    27782797                      OsiSolverInterface * solver = expandKnapsack(saveCoinModel,whichColumn,knapsackStart,
    27792798                                                                   knapsackRow,numberKnapsack,
    2780                                                                    storedAmpl,2,slpValue);
     2799                                                                   storedAmpl,logLevel,extra1,extra2);
    27812800                      if (solver) {
    27822801                        clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    27852804                        babModel->assignSolver(solver);
    27862805                        testOsiOptions=0;
     2806                        // Priorities already done
     2807                        free(info.priorities);
     2808                        info.priorities=NULL;
    27872809                      } else {
    27882810                        numberKnapsack=0;
     
    30753097                if (moreMipOptions>=0) {
    30763098                  printf("more mip options %d\n",moreMipOptions);
     3099                  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     3100                  if (moreMipOptions==10000) {
     3101                    // test memory saving
     3102                    moreMipOptions -= 10000;
     3103                    ClpSimplex * lpSolver = osiclp->getModelPtr();
     3104                    lpSolver->setPersistenceFlag(1);
     3105                    // switch off row copy if few rows
     3106                    if (lpSolver->numberRows()<150)
     3107                      lpSolver->setSpecialOptions(lpSolver->specialOptions()|256);
     3108                  }
    30773109                  if (((moreMipOptions+1)%1000000)!=0)
    30783110                    babModel->setSearchStrategy(moreMipOptions%1000000);
    3079                   OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
    30803111                  // go faster stripes
    30813112                  if( moreMipOptions >=999999) {
     
    34493480                  OsiObject ** objects = testOsiSolver->objects();
    34503481                  int numberObjects = testOsiSolver->numberObjects();
     3482                  int logLevel = parameters[log].intValue();
    34513483                  for (int iObj = 0;iObj<numberObjects;iObj++) {
    34523484                    // skip sos
    34533485                    OsiSOS * objSOS =
    34543486                      dynamic_cast <OsiSOS *>(objects[iObj]) ;
    3455                     if (objSOS)
     3487                    if (objSOS) {
     3488                      if (logLevel>2)
     3489                        printf("Set %d is SOS - priority %d\n",iObj,objSOS->priority());
    34563490                      continue;
     3491                    }
    34573492                    int iColumn = objects[iObj]->columnNumber();
    34583493                    if (iColumn>=0) {
     
    34773512                        objects[iObj]->setPriority(iPriority);
    34783513                    }
     3514                    if (logLevel>2)
     3515                      printf("Obj %d is int? - priority %d\n",iObj,objects[iObj]->priority());
    34793516                    if (pseudoUp&&pseudoUp[iColumn]) {
    34803517                      abort();
     
    37373774                    delete [] buildColumn;
    37383775                  }
    3739                   if (storedAmpl.sizeRowCuts())
    3740                     babModel->addCutGenerator(&storedAmpl,1,"AmplStored");
     3776                  if (storedAmpl.sizeRowCuts()) {
     3777                    //babModel->addCutGenerator(&storedAmpl,1,"AmplStored");
     3778                    int numberRowCuts = storedAmpl.sizeRowCuts();
     3779                    for (int i=0;i<numberRowCuts;i++) {
     3780                      const OsiRowCut * rowCutPointer = storedAmpl.rowCutPointer(i);
     3781                      babModel->makeGlobalCut(rowCutPointer);
     3782                    }
     3783                  }
    37413784                }
    37423785#endif
     3786#ifdef CLP_MALLOC_STATISTICS
     3787                malloc_stats();
     3788                malloc_stats2();
     3789#endif
     3790                if (outputFormat==5) {
     3791                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     3792                  lpSolver = osiclp->getModelPtr();
     3793                  lpSolver->setPersistenceFlag(1);
     3794                }
    37433795                babModel->branchAndBound(statistics);
     3796#ifdef CLP_MALLOC_STATISTICS
     3797                malloc_stats();
     3798                malloc_stats2();
     3799#endif
    37443800                checkSOS(babModel, babModel->solver());
    37453801              } else if (type==MIPLIB) {
     
    37503806                  strategy.setupPreProcessing(translate2[preProcess]);
    37513807                babModel->setStrategy(strategy);
     3808                if (outputFormat==5) {
     3809                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     3810                  lpSolver = osiclp->getModelPtr();
     3811                  lpSolver->setPersistenceFlag(1);
     3812                }
    37523813                CbcClpUnitTest(*babModel);
    37533814                goodModel=false;
Note: See TracChangeset for help on using the changeset viewer.