Changeset 529 for branches


Ignore:
Timestamp:
Feb 8, 2007 12:45:03 PM (13 years ago)
Author:
forrest
Message:

for nonlinear

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

Legend:

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

    r482 r529  
    366366                 generatorName_,numberRowCutsAfter-numberRowCutsBefore,nOdd);
    367367    }
     368    {
     369      // make all row cuts without test for duplicate
     370      int numberRowCutsAfter = cs.sizeRowCuts() ;
     371      int k ;
     372      for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
     373        OsiRowCut * thisCut = cs.rowCutPtr(k) ;
     374        thisCut->mutableRow().setTestForDuplicateIndex(false);
     375      }
     376    }
    368377#ifdef CBC_DEBUG
    369378    {
  • branches/devel/Cbc/src/CbcLinked.cpp

    r523 r529  
    33#include "CbcConfig.h"
    44
     5#ifndef COIN_HAS_LINK
    56#ifdef COIN_HAS_ASL
    67#define COIN_HAS_LINK
    78#endif
    8 #ifndef COIN_DEVELOP
    9 #undef COIN_HAS_LINK
    109#endif
    1110#ifdef COIN_HAS_LINK
     
    14571456    }
    14581457  }
     1458#if 0
     1459  //int fake[10]={3,4,2,5,5,3,1,11,2,0};
     1460  int fake[10]={11,5,5,4,3,3,2,2,1,0};
     1461  for (int kk=0;kk<10;kk++) {
     1462    setColUpper(kk,fake[kk]);
     1463    setColLower(kk,fake[kk]);
     1464  }
     1465#endif
    14591466  delete [] which;
    14601467}
     
    26722679            delete obj;
    26732680            fixVariables_[numberFix_++]=iColumn;
    2674             highPriority[iColumn]=2;
    2675           } else {
    26762681            highPriority[iColumn]=1;
    26772682          }
     
    26792684      }
    26802685    }
    2681     // All nonlinear terms must involve high priority (as known)
    2682     double * linear = new double[numberColumns];
    2683     int numberRows = coinModel_.numberRows();
    2684     for (int iRow=0;iRow<numberRows;iRow++) {
    2685       CoinPackedMatrix * row = quadraticRow(iRow,linear);
    2686       if (row) {
    2687         // see if valid
    2688         const double * element = row->getElements();
    2689         const int * columnLow = row->getIndices();
    2690         const CoinBigIndex * columnHigh = row->getVectorStarts();
    2691         const int * columnLength = row->getVectorLengths();
    2692         int numberLook = row->getNumCols();
    2693         int canSwap=0;
    2694         for (int i=0;i<numberLook;i++) {
    2695           // this one needs to be available
    2696           int iPriority = highPriority[i];
    2697           for (int j=columnHigh[i];j<columnHigh[i]+columnLength[i];j++) {
    2698             int iColumn = columnLow[j];
    2699             if (highPriority[iColumn]<=1) {
    2700               assert (highPriority[iColumn]==1);
    2701               if (iPriority==1) {
    2702                 canSwap=-1; // no good
    2703                 break;
    2704               } else {
    2705                 canSwap=1;
    2706               }
    2707             }
    2708           }
    2709         }
    2710         if (canSwap) {
    2711           if (canSwap>0) {
    2712             // rewrite row
    2713             /* get triples
    2714                then swap ones needed
    2715                then create packedmatrix
    2716                then replace row
    2717             */
    2718             int numberElements=columnHigh[numberLook];
    2719             int * columnHigh2 = new int [numberElements];
    2720             int * columnLow2 = new int [numberElements];
    2721             double * element2 = new double [numberElements];
    2722             for (int i=0;i<numberLook;i++) {
    2723               // this one needs to be available
    2724               int iPriority = highPriority[i];
    2725               if (iPriority==2) {
    2726                 for (int j=columnHigh[i];j<columnHigh[i]+columnLength[i];j++) {
    2727                   columnHigh2[j]=i;
    2728                   columnLow2[j]=columnLow[j];
    2729                   element2[j]=element[j];
    2730                 }
    2731               } else {
    2732                 for (int j=columnHigh[i];j<columnHigh[i]+columnLength[i];j++) {
    2733                   columnLow2[j]=i;
    2734                   columnHigh2[j]=columnLow[j];
    2735                   element2[j]=element[j];
    2736                 }
    2737               }
    2738             }
    2739             delete row;
    2740             row = new CoinPackedMatrix(true,columnHigh2,columnLow2,element2,numberElements);
    2741             delete [] columnHigh2;
    2742             delete [] columnLow2;
    2743             delete [] element2;
    2744             // Now replace row
    2745             replaceQuadraticRow(iRow,linear,row);
    2746             delete row;
    2747           } else {
    2748             delete row;
    2749             printf("Unable to use priority - row %d\n",iRow);
    2750             delete [] fixVariables_;
    2751             fixVariables_ = NULL;
    2752             numberFix_=0;
    2753             break;
    2754           }
    2755         }
    2756       }
    2757     }
     2686    CoinModel * newModel = coinModel_.reorder(highPriority);
     2687    if (newModel) {
     2688      coinModel_ = * newModel;
     2689    } else {
     2690      printf("Unable to use priorities\n");
     2691      delete [] fixVariables_;
     2692      fixVariables_ = NULL;
     2693      numberFix_=0;
     2694    }
     2695    delete newModel;
    27582696    delete [] highPriority;
    2759     delete [] linear;
    2760   }
    2761 }
    2762 // Replaces a quadratic row
    2763 void
    2764 OsiSolverLink::replaceQuadraticRow(int rowNumber,const double * linearRow, const CoinPackedMatrix * quadraticPart)
    2765 {
    2766   int numberColumns = coinModel_.numberColumns();
    2767   int numberRows = coinModel_.numberRows();
    2768   assert (rowNumber>=0&&rowNumber<numberRows);
    2769   CoinModelLink triple=coinModel_.firstInRow(rowNumber);
    2770   while (triple.column()>=0) {
    2771     int iColumn = triple.column();
    2772     coinModel_.deleteElement(rowNumber,iColumn);
    2773     // triple stale - so start over
    2774     triple=coinModel_.firstInRow(rowNumber);
    2775   }
    2776   const double * element = quadraticPart->getElements();
    2777   const int * column = quadraticPart->getIndices();
    2778   const CoinBigIndex * columnStart = quadraticPart->getVectorStarts();
    2779   const int * columnLength = quadraticPart->getVectorLengths();
    2780   int numberLook = quadraticPart->getNumCols();
    2781   int i;
    2782   for (i=0;i<numberLook;i++) {
    2783     if (!columnLength[i]) {
    2784       // just linear part
    2785       if (linearRow[i])
    2786         coinModel_.setElement(rowNumber,i,linearRow[i]);
    2787     } else {
    2788       char temp[10000];
    2789       int put=0;
    2790       char temp2[30];
    2791       bool first=true;
    2792       if (linearRow[i]) {
    2793         sprintf(temp,"%g",linearRow[i]);
    2794         first=false;
    2795         put = strlen(temp);
    2796       }
    2797       for (int j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
    2798         int jColumn = column[j];
    2799         double value = element[j];
    2800         if (value<0.0||first)
    2801           sprintf(temp2,"%g*c%7.7d",value,jColumn);
    2802         else
    2803           sprintf(temp2,"+%g*c%7.7d",value,jColumn);
    2804         int nextPut = put + strlen(temp2);
    2805         assert (nextPut<10000);
    2806         strcpy(temp+put,temp2);
    2807         put = nextPut;
    2808       }
    2809       coinModel_.setElement(rowNumber,i,temp);
    2810     }
    2811   }
    2812   // rest of linear
    2813   for (;i<numberColumns;i++) {
    2814     if (linearRow[i])
    2815       coinModel_.setElement(rowNumber,i,linearRow[i]);
    28162697  }
    28172698}
     
    29052786  int returnCode=0;
    29062787  if (allFixed) {
     2788    // solve anyway
     2789    OsiClpSolverInterface::resolve();
     2790    if (!isProvenOptimal()) {
     2791      printf("cutoff before fathoming\n");
     2792      return -1;
     2793    }
    29072794    // all fixed so we can reformulate
    29082795    OsiClpSolverInterface newSolver;
     
    29382825      }
    29392826    }
    2940     //if (fabs(sum-8.3)<1.0e-5)
    2941     //printf("possible\n");
     2827    int fake[]={5,4,3,2,0,0,0};
     2828    bool onOptimalPath=true;
     2829    for (i=0;i<7;i++) {
     2830      if ((int) upper[i]!=fake[i])
     2831        onOptimalPath=false;
     2832    }
     2833    if (onOptimalPath)
     2834      printf("possible\n");
    29422835    if (zeroObjective) {
    29432836      // randomize objective
     
    30412934    cbcModel->initialSolve();
    30422935    //double cutoff = model_->getCutoff();
    3043     cbcModel->setCutoff(1.0e50);
     2936    if (zeroObjective||!cbcModel_)
     2937      cbcModel->setCutoff(1.0e50);
     2938    else
     2939      cbcModel->setCutoff(cbcModel_->getCutoff());
    30442940    // to change exits
    30452941    bool isFeasible=false;
     
    62176113  return *this;
    62186114}
     6115/* Expands out all possible combinations for a knapsack
     6116   If buildObj NULL then just computes space needed - returns number elements
     6117   On entry numberOutput is maximum allowed, on exit it is number needed or
     6118   -1 (as will be number elements) if maximum exceeded.  numberOutput will have at
     6119   least space to return values which reconstruct input.
     6120   Rows returned will be original rows but no entries will be returned for
     6121   any rows all of whose entries are in knapsack.  So up to user to allow for this.
     6122   If reConstruct >=0 then returns number of entrie which make up item "reConstruct"
     6123   in expanded knapsack.  Values in buildRow and buildElement;
     6124*/
     6125int
     6126CoinModel::expandKnapsack(int knapsackRow, int & numberOutput,double * buildObj, CoinBigIndex * buildStart,
     6127                          int * buildRow, double * buildElement,int reConstruct) const
     6128{
     6129  /* mark rows
     6130     -2 in knapsack and other variables
     6131     -1 not involved
     6132     0 only in knapsack
     6133  */
     6134  int * markRow = new int [numberRows_];
     6135  int iRow;
     6136  int iColumn;
     6137  int * whichColumn = new int [numberColumns_];
     6138  for (iColumn=0;iColumn<numberColumns_;iColumn++)
     6139    whichColumn[iColumn]=-1;
     6140  int numJ=0;
     6141  for (iRow=0;iRow<numberRows_;iRow++)
     6142    markRow[iRow]=-1;
     6143  CoinModelLink triple;
     6144  triple=firstInRow(knapsackRow);
     6145  while (triple.column()>=0) {
     6146    int iColumn = triple.column();
     6147    const char *  el = getElementAsString(knapsackRow,iColumn);
     6148    assert (!strcmp("Numeric",el));
     6149    whichColumn[iColumn]=numJ;
     6150    numJ++;
     6151    triple=next(triple);
     6152  }
     6153  for (iRow=0;iRow<numberRows_;iRow++) {
     6154    triple=firstInRow(iRow);
     6155    int type=-3;
     6156    while (triple.column()>=0) {
     6157      int iColumn = triple.column();
     6158      if (whichColumn[iColumn]>=0) {
     6159        if (type==-3)
     6160          type=0;
     6161        else if (type!=0)
     6162          type=-2;
     6163      } else {
     6164        if (type==-3)
     6165          type=-1;
     6166        else if (type==0)
     6167          type=-2;
     6168      }
     6169      triple=next(triple);
     6170    }
     6171    if (type==-3)
     6172      type=-1;
     6173    markRow[iRow]=type;
     6174  }
     6175  int * bound = new int [numberColumns_+1];
     6176  int * whichRow = new int [numberRows_];
     6177  ClpSimplex tempModel;
     6178  CoinModel tempModel2(*this);
     6179  tempModel.loadProblem(tempModel2);
     6180  int * stack = new int [numberColumns_+1];
     6181  double * size = new double [numberColumns_+1];
     6182  double * rhsOffset = new double[numberRows_];
     6183  int * build = new int[numberColumns_];
     6184  int maxNumber=numberOutput;
     6185  numJ=0;
     6186  double minSize = getRowLower(knapsackRow);
     6187  double maxSize = getRowUpper(knapsackRow);
     6188  double offset=0.0;
     6189  triple=firstInRow(knapsackRow);
     6190  while (triple.column()>=0) {
     6191    iColumn = triple.column();
     6192    double lowerColumn=columnLower(iColumn);
     6193    double upperColumn=columnUpper(iColumn);
     6194    double gap = upperColumn-lowerColumn;
     6195    assert (fabs(floor(gap+0.5)-gap)<1.0e-5);
     6196    whichColumn[numJ]=iColumn;
     6197    bound[numJ]=(int) gap;
     6198    size[numJ++]=triple.value();
     6199    offset += triple.value()*lowerColumn;
     6200    triple=next(triple);
     6201  } 
     6202  int jRow;
     6203  for (iRow=0;iRow<numberRows_;iRow++)
     6204    whichRow[iRow]=iRow;
     6205  ClpSimplex smallModel(&tempModel,numberRows_,whichRow,numJ,whichColumn,true,true,true);
     6206  // modify rhs to allow for nonzero lower bounds
     6207  double * rowLower = smallModel.rowLower();
     6208  double * rowUpper = smallModel.rowUpper();
     6209  const double * columnLower = smallModel.columnLower();
     6210  //const double * columnUpper = smallModel.columnUpper();
     6211  const CoinPackedMatrix * matrix = smallModel.matrix();
     6212  const double * element = matrix->getElements();
     6213  const int * row = matrix->getIndices();
     6214  const CoinBigIndex * columnStart = matrix->getVectorStarts();
     6215  const int * columnLength = matrix->getVectorLengths();
     6216  const double * objective = smallModel.objective();
     6217  double objectiveOffset=0.0;
     6218  CoinZeroN(rhsOffset,numberRows_);
     6219  for (iColumn=0;iColumn<numJ;iColumn++) {
     6220    double lower = columnLower[iColumn];
     6221    if (lower) {
     6222      objectiveOffset += objective[iColumn];
     6223      for (CoinBigIndex j=columnStart[iColumn];
     6224           j<columnStart[iColumn]+columnLength[iColumn];j++) {
     6225        double value = element[j]*lower;
     6226        int kRow = row[j];
     6227        rhsOffset[kRow] += value;
     6228        if (rowLower[kRow]>-1.0e20)
     6229          rowLower[kRow] -= value;
     6230        if (rowUpper[kRow]<1.0e20)
     6231          rowUpper[kRow] -= value;
     6232      }
     6233    }
     6234  }
     6235  // relax
     6236  for (jRow=0;jRow<numberRows_;jRow++) {
     6237    if (markRow[jRow]==0&&knapsackRow!=jRow) {
     6238      if (rowLower[jRow]>-1.0e20)
     6239        rowLower[jRow] -= 1.0e-7;
     6240      if (rowUpper[jRow]<1.0e20)
     6241        rowUpper[jRow] += 1.0e-7;
     6242    } else {
     6243      rowLower[jRow]=-COIN_DBL_MAX;
     6244      rowUpper[jRow]=COIN_DBL_MAX;
     6245    }
     6246  }
     6247  double * rowActivity = smallModel.primalRowSolution();
     6248  CoinZeroN(rowActivity,numberRows_);
     6249  maxSize -= offset;
     6250  minSize -= offset;
     6251  // now generate
     6252  int i;
     6253  int iStack=numJ;
     6254  for (i=0;i<numJ;i++) {
     6255    stack[i]=0;
     6256  }
     6257  double tooMuch = 10.0*maxSize;
     6258  stack[numJ]=1;
     6259  size[numJ]=tooMuch;
     6260  bound[numJ]=0;
     6261  double sum=tooMuch;
     6262  numberOutput=0;
     6263  int nelCreate=0;
     6264  /* typeRun is - 0 for initial sizes
     6265                  1 for build
     6266                  2 for reconstruct
     6267  */
     6268  int typeRun = buildObj ? 1 : 0;
     6269  if (reConstruct>=0) {
     6270    assert (buildRow&&buildElement);
     6271    typeRun=2;
     6272  }
     6273  if (typeRun==1)
     6274    buildStart[0]=0;
     6275  while (iStack>=0) {
     6276    if (sum>=minSize&&sum<=maxSize) {
     6277      double checkSize =0.0;
     6278      bool good=true;
     6279      int nRow=0;
     6280      double obj=objectiveOffset;
     6281      CoinZeroN(rowActivity,nRow);
     6282      for (iColumn=0;iColumn<numJ;iColumn++) {
     6283        int iValue = stack[iColumn];
     6284        if (iValue>bound[iColumn]) {
     6285          good=false;
     6286          break;
     6287        } else if (iValue) {
     6288          obj += objective[iColumn]*iValue;
     6289          for (CoinBigIndex j=columnStart[iColumn];
     6290               j<columnStart[iColumn]+columnLength[iColumn];j++) {
     6291            double value = element[j]*iValue;
     6292            int kRow = row[j];
     6293            if (rowActivity[kRow]) {
     6294              rowActivity[kRow] += value;
     6295              if (!rowActivity[kRow])
     6296                rowActivity[kRow]=1.0e-100;
     6297            } else {
     6298              build[nRow++]=kRow;
     6299              rowActivity[kRow]=value;
     6300            }
     6301          }
     6302        }
     6303      }
     6304      if (good) {
     6305        for (jRow=0;jRow<nRow;jRow++) {
     6306          int kRow=build[jRow];
     6307          double value = rowActivity[kRow];
     6308          if (value>rowUpper[kRow]||value<rowLower[kRow]) {
     6309            good=false;
     6310            break;
     6311          }
     6312        }
     6313      }
     6314      if (good) {
     6315        if (typeRun==1) {
     6316          buildObj[numberOutput]=obj;
     6317          for (jRow=0;jRow<nRow;jRow++) {
     6318            int kRow=build[jRow];
     6319            double value = rowActivity[kRow];
     6320            if (markRow[kRow]<0&&fabs(value)>1.0e-13) {
     6321              buildElement[nelCreate]=value;
     6322              buildRow[nelCreate++]=kRow;
     6323            }
     6324          }
     6325          buildStart[numberOutput+1]=nelCreate;
     6326        } else if (!typeRun) {
     6327          for (jRow=0;jRow<nRow;jRow++) {
     6328            int kRow=build[jRow];
     6329            double value = rowActivity[kRow];
     6330            if (markRow[kRow]<0&&fabs(value)>1.0e-13) {
     6331              nelCreate++;
     6332            }
     6333          }
     6334        }
     6335        if (typeRun==2&&reConstruct==numberOutput) {
     6336          // build and exit
     6337          nelCreate=0;
     6338          for (iColumn=0;iColumn<numJ;iColumn++) {
     6339            int iValue = stack[iColumn];
     6340            if (iValue) {
     6341              buildRow[nelCreate]=whichColumn[iColumn];
     6342              buildElement[nelCreate++]=iValue;
     6343            }
     6344          }
     6345          numberOutput=1;
     6346          for (i=0;i<numJ;i++) {
     6347            bound[i]=0;
     6348          }
     6349          break;
     6350        }
     6351        numberOutput++;
     6352        if (numberOutput>maxNumber) {
     6353          nelCreate=-1;
     6354          numberOutput=-1;
     6355          for (i=0;i<numJ;i++) {
     6356            bound[i]=0;
     6357          }
     6358          break;
     6359        }
     6360        for (int j=0;j<numJ;j++) {
     6361          checkSize += stack[j]*size[j];
     6362        }
     6363        assert (fabs(sum-checkSize)<1.0e-3);
     6364      }
     6365      for (jRow=0;jRow<nRow;jRow++) {
     6366        int kRow=build[jRow];
     6367        rowActivity[kRow]=0.0;
     6368      }
     6369    }
     6370    if (sum>maxSize||stack[iStack]>bound[iStack]) {
     6371      sum -= size[iStack]*stack[iStack];
     6372      stack[iStack--]=0;
     6373      if (iStack>=0) {
     6374        stack[iStack] ++;
     6375        sum += size[iStack];
     6376      }
     6377    } else {
     6378      // must be less
     6379      // add to last possible
     6380      iStack = numJ-1;
     6381      sum += size[iStack];
     6382      stack[iStack]++;
     6383    }
     6384  }
     6385  //printf("%d will be created\n",numberOutput);
     6386  delete [] whichColumn;
     6387  delete [] whichRow;
     6388  delete [] bound;
     6389  delete [] stack;
     6390  delete [] size;
     6391  delete [] rhsOffset;
     6392  delete [] build;
     6393  delete [] markRow;
     6394  return nelCreate;
     6395}
    62196396#endif
  • branches/devel/Cbc/src/CbcLinked.hpp

    r523 r529  
    88   CglTemporary
    99*/
     10#ifndef COIN_HAS_LINK
    1011#ifdef COIN_HAS_ASL
    1112#define COIN_HAS_LINK
     13#endif
    1214#endif
    1315#ifdef COIN_HAS_LINK
     
    141143  /// Gets correct form for a quadratic row - user to delete
    142144  CoinPackedMatrix * quadraticRow(int rowNumber,double * linear) const;
    143   /// Replaces a quadratic row
    144   void replaceQuadraticRow(int rowNumber,const double * linear, const CoinPackedMatrix * quadraticPart);
    145145  /// Default meshSize
    146146  inline double defaultMeshSize() const
  • branches/devel/Cbc/src/CbcModel.cpp

    r514 r529  
    1313//#define CHECK_NODE_FULL
    1414//#define NODE_LOG
     15//#define GLOBAL_CUTS_JUST_POINTERS
    1516#include <cassert>
    1617#include <cmath>
     
    274275
    275276#endif /* CHECK_CUT_COUNTS */
     277
     278
     279
     280//#define CHECK_CUT_SIZE
     281#ifdef CHECK_CUT_SIZE
     282
     283/*
     284  Routine to verify that cut reference counts are correct.
     285*/
     286void verifyCutSize (const CbcTree * branchingTree, CbcModel &model)
     287{
     288
     289  int j ;
     290  int nNodes = branchingTree->size() ;
     291  int totalCuts=0;
     292
     293/*
     294  cut.tempNumber_ exists for the purpose of doing this verification. Clear it
     295  in all cuts. We traverse the tree by starting from each live node and working
     296  back to the root. At each CbcNodeInfo, check for cuts.
     297*/
     298  for (j = 0 ; j < nNodes ; j++) {
     299    CbcNode *node = branchingTree->nodePointer(j) ;
     300    CbcNodeInfo * nodeInfo = node->nodeInfo() ;
     301    assert (node->nodeInfo()->numberBranchesLeft()) ;
     302    while (nodeInfo) {
     303      totalCuts += nodeInfo->numberCuts();
     304      nodeInfo = nodeInfo->parent() ;
     305    }
     306  }
     307  printf("*** CHECKING cuts (size) after %d nodes - %d cuts\n",model.getNodeCount(),totalCuts) ;
     308  return ;
     309}
     310
     311#endif /* CHECK_CUT_SIZE */
    276312
    277313}
     
    12881324    if ((numberNodes_%1000) == 0) {
    12891325      bool redoTree=nodeCompare_->every1000Nodes(this, numberNodes_) ;
     1326#ifdef CHECK_CUT_SIZE
     1327      verifyCutSize (tree_, *this);
     1328#endif
    12901329      // redo tree if wanted
    12911330      if (redoTree)
     
    15001539      } else {
    15011540        // normal
     1541        //int zzzzzz=0;
     1542        //if (zzzzzz)
     1543        //solver_->writeMps("before");
    15021544        feasible = solveWithCuts(cuts,maximumCutPasses_,node);
    15031545      }
    15041546      if ((specialOptions_&1)!=0&&onOptimalPath) {
    1505         assert (solver_->getRowCutDebugger()) ;
     1547        if (!solver_->getRowCutDebugger()) {
     1548          // dj fix did something???
     1549          solver_->writeMps("infeas2");
     1550          assert (solver_->getRowCutDebugger()) ;
     1551        }
    15061552      }
    15071553      if (statistics_) {
     
    40634109      resizeWhichGenerator(numberViolated, numberViolated+numberCuts);
    40644110      for ( i = 0 ; i < numberCuts ; i++)
    4065       { const OsiColCut *thisCut = globalCuts_.colCutPtr(i) ;
     4111      { OsiColCut *thisCut = globalCuts_.colCutPtr(i) ;
    40664112        if (thisCut->violated(cbcColSolution_)>primalTolerance) {
    40674113          printf("Global cut added - violation %g\n",
    40684114                 thisCut->violated(cbcColSolution_)) ;
    40694115          whichGenerator_[numberViolated++]=-1;
     4116#ifndef GLOBAL_CUTS_JUST_POINTERS
    40704117          theseCuts.insert(*thisCut) ;
     4118#else
     4119          theseCuts.insert(thisCut) ;
     4120#endif
    40714121        }
    40724122      }
     
    40754125      resizeWhichGenerator(numberViolated, numberViolated+numberCuts);
    40764126      for ( i = 0;i<numberCuts;i++) {
    4077         const OsiRowCut * thisCut = globalCuts_.rowCutPtr(i) ;
     4127        OsiRowCut * thisCut = globalCuts_.rowCutPtr(i) ;
    40784128        if (thisCut->violated(cbcColSolution_)>primalTolerance) {
    40794129          //printf("Global cut added - violation %g\n",
    40804130          // thisCut->violated(cbcColSolution_)) ;
    40814131          whichGenerator_[numberViolated++]=-1;
     4132#ifndef GLOBAL_CUTS_JUST_POINTERS
    40824133          theseCuts.insert(*thisCut) ;
     4134#else
     4135          theseCuts.insert(thisCut) ;
     4136#endif
    40834137        }
    40844138      }
     
    42614315        if (thisCut->globallyValid()) {
    42624316          // add to global list
    4263           globalCuts_.insert(*thisCut) ;
     4317          OsiRowCut newCut(*thisCut);
     4318          newCut.setGloballyValid(2);
     4319          newCut.mutableRow().setTestForDuplicateIndex(false);
     4320          globalCuts_.insert(newCut) ;
    42644321        }
    42654322      }
     
    42694326        if (thisCut->globallyValid()) {
    42704327          // add to global list
    4271           globalCuts_.insert(*thisCut) ;
     4328          OsiColCut newCut(*thisCut);
     4329          newCut.setGloballyValid(2);
     4330          globalCuts_.insert(newCut) ;
    42724331        }
    42734332      }
     
    46334692            {       
    46344693              whichGenerator_[numberNewCuts_++]=-1;
     4694#ifndef GLOBAL_CUTS_JUST_POINTERS
    46354695              cuts.insert(globalCuts_.rowCut(i)) ;
     4696#else
     4697              cuts.insert(globalCuts_.rowCutPtr(i)) ;
     4698#endif
    46364699            }
    46374700          numberNewCuts_ = lastNumberCuts+numberToAdd;
     
    64976560                        //           }
    64986561                        // add to global list
    6499                         globalCuts_.insert(*thisCut);
     6562                        OsiRowCut newCut(*thisCut);
     6563                        newCut.setGloballyValid(2);
     6564                        newCut.mutableRow().setTestForDuplicateIndex(false);
     6565                        globalCuts_.insert(newCut) ;
    65006566                        generator_[i]->incrementNumberCutsInTotal();
    65016567                      }
     
    65756641      Double check the solution to catch pretenders.
    65766642    */
     6643    double saveObjectiveValue = objectiveValue;
    65776644    objectiveValue =checkSolution(cutoff,solution,fixVariables,objectiveValue);
    65786645    if (objectiveValue>cutoff&&objectiveValue<cutoff+1.0e-8+1.0e-8*fabs(cutoff))
     
    65976664     
    65986665      cutoff = bestObjective_-dblParam_[CbcCutoffIncrement];
     6666      // But allow for rounding errors
     6667      if (dblParam_[CbcCutoffIncrement] == 1e-5)
     6668        cutoff = CoinMin(bestObjective_,saveObjectiveValue)-1.0e-5;
    65996669      // This is not correct - that way cutoff can go up if maximization
    66006670      //double direction = solver_->getObjSense();
     
    66496719              }
    66506720              // add to global list
    6651               globalCuts_.insert(*thisCut);
     6721              OsiRowCut newCut(*thisCut);
     6722              newCut.setGloballyValid(2);
     6723              newCut.mutableRow().setTestForDuplicateIndex(false);
     6724              globalCuts_.insert(newCut) ;
    66526725              generator_[i]->incrementNumberCutsInTotal();
    66536726            }
     
    66606733        if (thisCut->globallyValid()) {
    66616734          // add to global list
    6662           globalCuts_.insert(*thisCut);
     6735          OsiColCut newCut(*thisCut);
     6736          newCut.setGloballyValid(2);
     6737          globalCuts_.insert(newCut) ;
    66636738        }
    66646739      }
     
    81328207        thisCut.setUb(rowUpper[iRow]);
    81338208        int start = rowStart[iRow];
    8134         thisCut.setRow(rowLength[iRow],column+start,elementByRow+start);
     8209        thisCut.setRow(rowLength[iRow],column+start,elementByRow+start,false);
     8210        thisCut.setGloballyValid(2);
    81358211        globalCuts_.insert(thisCut) ;
    81368212      }
     
    81408216    solver_->deleteRows(nDelete,whichDelete);
    81418217  delete [] whichDelete;
     8218}
     8219// Make given cut into a global cut
     8220void
     8221CbcModel::makeGlobalCut(const OsiRowCut * cut)
     8222{
     8223  OsiRowCut newCut(*cut);
     8224  newCut.setGloballyValid(2);
     8225  newCut.mutableRow().setTestForDuplicateIndex(false);
     8226  globalCuts_.insert(newCut) ;
     8227}
     8228// Make given cut into a global cut
     8229void
     8230CbcModel::makeGlobalCut(const OsiRowCut & cut)
     8231{
     8232  OsiRowCut newCut(cut);
     8233  newCut.setGloballyValid(2);
     8234  newCut.mutableRow().setTestForDuplicateIndex(false);
     8235  globalCuts_.insert(newCut) ;
    81428236}
    81438237void
     
    82898383      algorithm = takeHint ? -1 : 1;
    82908384      assert (algorithm==-1);*/
    8291     clpSolver->setHintParam(OsiDoDualInResolve,true,OsiHintTry);
     8385    //clpSolver->setHintParam(OsiDoDualInResolve,true,OsiHintTry);
    82928386    ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    82938387    int save = clpSimplex->specialOptions();
  • branches/devel/Cbc/src/CbcModel.hpp

    r481 r529  
    277277    /// Make given rows (L or G) into global cuts and remove from lp
    278278    void makeGlobalCuts(int numberRows,const int * which);
     279    /// Make given cut into a global cut
     280    void makeGlobalCut(const OsiRowCut * cut);
     281    /// Make given cut into a global cut
     282    void makeGlobalCut(const OsiRowCut & cut);
    279283  //@}
    280284
  • branches/devel/Cbc/src/CbcNode.cpp

    r490 r529  
    139139  assert(!numberPointingToThis_);
    140140  // But they may be some left (max nodes?)
    141   for (int i=0;i<numberCuts_;i++)
     141  for (int i=0;i<numberCuts_;i++) {
     142#ifndef GLOBAL_CUTS_JUST_POINTERS
    142143    delete cuts_[i];
    143 
     144#else
     145    if (cuts_[i]->globallyValidAsInteger()!=2)
     146      delete cuts_[i];
     147#endif
     148  }
    144149  delete [] cuts_;
    145150  if (owner_)
     
    169174      if (!number) {
    170175        //printf("info %x del cut %d %x\n",this,i,cuts_[i]);
     176#ifndef GLOBAL_CUTS_JUST_POINTERS
    171177        delete cuts_[i];
     178#else
     179        if (cuts_[i]->globallyValidAsInteger()!=2)
     180          delete cuts_[i];
     181#endif
    172182        cuts_[i]=NULL;
    173183      }
     
    214224          }
    215225          if (!number) {
     226#ifndef GLOBAL_CUTS_JUST_POINTERS
    216227            delete thisInfo->cuts_[i];
     228#else
     229            if (thisInfo->cuts_[i]->globallyValidAsInteger()!=2)
     230              delete thisInfo->cuts_[i];
     231#endif
    217232            thisInfo->cuts_[i]=NULL;
    218233          }
     
    374389    last=j;
    375390    int number = cuts_[j]->decrement();
    376     if (!number)
     391    if (!number) {
     392#ifndef GLOBAL_CUTS_JUST_POINTERS
    377393      delete cuts_[j];
     394#else
     395      if (cuts_[j]->globallyValidAsInteger()!=2)
     396        delete cuts_[j];
     397#endif
     398    }
    378399    cuts_[j]=NULL;
    379400  }
     
    394415    int iCut=which[i];
    395416    int number = cuts_[iCut]->decrement();
    396     if (!number)
     417    if (!number) {
     418#ifndef GLOBAL_CUTS_JUST_POINTERS
    397419      delete cuts_[iCut];
     420#else
     421      if (cuts_[iCut]->globallyValidAsInteger()!=2)
     422        delete cuts_[iCut];
     423#endif
     424    }
    398425    cuts_[iCut]=NULL;
    399426  }
  • branches/devel/Cbc/src/Cbc_ampl.cpp

    r523 r529  
    135135        { "priority", 0, ASL_Sufkind_var },
    136136#endif
     137        { "cut", 0, ASL_Sufkind_con },
    137138        { "direction", 0, ASL_Sufkind_var },
    138139        { "downPseudocost", 0, ASL_Sufkind_var | ASL_Sufkind_real },
     
    163164  double *pseudoUp, *pseudoDown;
    164165  int *priority, *direction;
    165   SufDesc *dpup, *dpdown, *dpri, *ddir;
     166  // To label cuts
     167  int *cut;
     168  SufDesc *dpup, *dpdown, *dpri, *ddir, *dcut;
    166169 
    167170  ddir = suf_get("direction", ASL_Sufkind_var);
     
    169172  dpri = suf_get("priority", ASL_Sufkind_var);
    170173  priority = dpri->u.i;
     174  dcut = suf_get("cut", ASL_Sufkind_con);
     175  cut = dcut->u.i;
    171176  dpdown = suf_get("downPseudocost", ASL_Sufkind_var);
    172177  pseudoDown = dpdown->u.r;
     
    206211              "Treating %d negative .priority values as 0\n",
    207212              badpri);
     213  }
     214  int numberRows = saveInfo->numberRows;
     215  if (cut) {
     216    int badcut=0;
     217    saveInfo->cut= (int *) malloc(numberRows*sizeof(int));
     218    for (i=0;i<numberRows;i++) {
     219      int value = cut[i];
     220      if (value<0) {
     221        badcut++;
     222        value=0;
     223      }
     224      saveInfo->cut[i]=value;
     225    }
     226    if (badcut)
     227      fprintf(Stderr,
     228              "Treating %d negative cut values as 0\n",
     229              badcut);
    208230  }
    209231  if (pseudoDown||pseudoUp) {
     
    467489    info->numberBinary=nbv;
    468490    info->numberIntegers=niv;
    469     if (nbv+niv+nlvbi+nlvci+nlvoi>0)
     491    if (nbv+niv+nlvbi+nlvci+nlvoi>0) {
    470492      mip_stuff(); // get any extra info
     493      if (info->cut)
     494        model->setCutMarker(info->numberRows,info->cut);
     495      if (info->priorities)
     496        model->setPriorities(info->numberColumns,info->priorities);
     497    }
    471498  }
    472499  /* add -solve - unless something there already
     
    576603  free(info->sosReference);
    577604  info->sosReference=NULL;
     605  free(info->cut);
     606  info->cut=NULL;
    578607  ASL_free(&asl);
    579608}
     
    654683    referenceSOS_(NULL),
    655684    priority_(NULL),
     685    cut_(NULL),
    656686    logLevel_(0),
    657687    type_(-1),
     
    928958      matrixByRow.appendRow(k,column,element);
    929959    }
     960    delete [] column;
     961    delete [] element;
    930962    numberRows=n_con;
    931963    numberColumns=n_var;
     
    9801012    setColumnIsInteger(i,true);;
    9811013  }
     1014  free(columnLower);
     1015  free(columnUpper);
     1016  free(rowLower);
     1017  free(rowUpper);
     1018  free(objective);
    9821019  // do names
    9831020  int iRow;
     
    9871024    setRowName(iRow,name);
    9881025  }
    989    
    9901026  int iColumn;
    9911027  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     
    11161152    }
    11171153  }
     1154  free(colqp);
     1155  free(z);
    11181156  // see if any sos
    11191157  {
Note: See TracChangeset for help on using the changeset viewer.