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

for nonlinear

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.