Changeset 140 for trunk


Ignore:
Timestamp:
May 20, 2005 5:21:02 PM (15 years ago)
Author:
forrest
Message:

memory leak

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CbcModel.cpp

    r137 r140  
    1616#include "CoinWarmStartBasis.hpp"
    1717#include "CoinPackedMatrix.hpp"
     18#include "CoinHelperFunctions.hpp"
    1819#include "CbcBranchActual.hpp"
    1920#include "CbcBranchDynamic.hpp"
     
    549550  int numberNewCuts = 0 ;
    550551  // Array to mark solution
     552  delete [] usedInSolution_;
    551553  usedInSolution_ = new int[numberColumns];
    552554  CoinZeroN(usedInSolution_,numberColumns);
     
    683685  if (newNode)
    684686  { continuousObjective_ = newNode->objectiveValue() ;
     687    delete [] continuousSolution_;
    685688    continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),
    686689                                             numberColumns);
     
    19251928  delete [] currentSolution_;
    19261929  currentSolution_=NULL;
    1927   testSolution_=currentSolution_;
     1930  delete [] continuousSolution_;
     1931  continuousSolution_=NULL;
     1932  delete [] usedInSolution_;
     1933  usedInSolution_ = NULL;
     1934  testSolution_=NULL;
    19281935  delete [] integerVariable_;
    19291936  integerVariable_=NULL;
     
    41514158    if (!bestSolution_)
    41524159      bestSolution_ = new double[numberColumns];
    4153     memcpy(bestSolution_,solution,numberColumns*sizeof(double));
     4160    CoinCopyN(solution,numberColumns,bestSolution_);
    41544161
    41554162    cutoff = bestObjective_-dblParam_[CbcCutoffIncrement];
  • trunk/CbcNode.cpp

    r137 r140  
    18061806  double * sort = new double[numberObjects];
    18071807  int * whichObject = new int[numberObjects];
     1808  int * whichColumn = new int[2*numberObjects+1];
    18081809  CbcStrongInfo * fixObject = new CbcStrongInfo[numberObjects];
    18091810  double estimatedDegradation=0.0;
     
    18181819    int numberIntegerInfeasibilities=0; // without odd ones
    18191820    int numberToDo=0;
     1821    double averageDown=0.0;
     1822    int numberDown=0;
     1823    double averageUp=0.0;
     1824    int numberUp=0;
     1825    int iBestNot=-1;
     1826    int iBestGot=-1;
     1827    double best=0.0;
    18201828   
    18211829    // We may go round this loop twice (only if we think we have solution)
     
    18431851      */
    18441852      numberToDo=0;
     1853      averageDown=0.0;
     1854      numberDown=0;
     1855      averageUp=0.0;
     1856      numberUp=0;
     1857      iBestNot=-1;
     1858      double bestNot=0.0;
     1859      iBestGot=-1;
     1860      best=0.0;
    18451861      for (i=0;i<numberObjects;i++) {
    1846         const CbcObject * object = model->object(i);
     1862        CbcObject * object = model->modifiableObject(i);
     1863        CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
     1864          dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
     1865        assert(dynamicObject);
    18471866        int preferredWay;
    18481867        double infeasibility = object->infeasibility(preferredWay);
    18491868        int priorityLevel = object->priority();
     1869        bool gotDown;
     1870        if (dynamicObject->numberTimesDown()) {
     1871          averageDown += dynamicObject->downDynamicPseudoCost();
     1872          numberDown++;
     1873          gotDown=true;
     1874        } else {
     1875          gotDown=false;
     1876        }
     1877        bool gotUp;
     1878        if (dynamicObject->numberTimesUp()) {
     1879          averageUp += dynamicObject->upDynamicPseudoCost();
     1880          numberUp++;
     1881          gotUp=true;
     1882        } else {
     1883          gotUp=false;
     1884        }
    18501885        if (infeasibility) {
    18511886          // Increase estimated degradation to solution
     
    18561891            numberToDo=0;
    18571892            bestPriority = priorityLevel;
     1893            iBestGot=-1;
     1894            best=0.0;
    18581895          } else if (priorityLevel>bestPriority) {
    18591896            continue;
    18601897          }
    18611898          // Check for suitability based on infeasibility.
    1862           sort[numberToDo]=-infeasibility;
     1899          if (gotDown||gotUp) {
     1900            sort[numberToDo]=-infeasibility;
     1901            if (infeasibility>best) {
     1902              best=infeasibility;
     1903              iBestGot=numberToDo;
     1904            }
     1905            whichColumn[numberToDo]=-1; // range info not wanted
     1906          } else {
     1907            int iColumn = dynamicObject->columnNumber();
     1908            sort[numberToDo]=saveSolution[iColumn]-floor(saveSolution[iColumn]);
     1909            if (fabs(sort[numberToDo])>bestNot) {
     1910              iBestNot=numberToDo;
     1911              bestNot = fabs(sort[numberToDo]);
     1912            }
     1913            whichColumn[numberToDo]=dynamicObject->columnNumber();
     1914          }
    18631915          whichObject[numberToDo++]=i;
    18641916        }
     
    19101962    bool solveAll=false; // set true to say look at all even if some fixed (experiment)
    19111963    solveAll=true;
     1964    // skip if solution
     1965    if (!numberUnsatisfied_)
     1966      break;
    19121967    // worth trying if too many times
    19131968    // Save basis
     
    19191974      solver->setIntParam(OsiMaxNumIterationHotStart,100);
    19201975   
    1921     // Sort
    1922     CoinSort_2(sort,sort+numberToDo,whichObject);
    19231976    // Say which one will be best
    19241977    int whichChoice=0;
    1925     int bestChoice=-1;
     1978    int bestChoice;
     1979    if (iBestGot>=0)
     1980      bestChoice=iBestGot;
     1981    else
     1982      bestChoice=iBestNot;
     1983    assert (bestChoice>=0);
    19261984    // If we have hit max time don't do strong branching
    19271985    bool hitMaxTime = ( CoinCpuTime()-model->getDblParam(CbcModel::CbcStartSeconds) >
     
    19291987    // also give up if we are looping round too much
    19301988    if (hitMaxTime||numberPassesLeft<=0) {
    1931       int iObject = whichObject[0];
     1989      int iObject = whichObject[bestChoice];
    19321990      CbcObject * object = model->modifiableObject(iObject);
    19331991      int preferredWay;
     
    19401998      int easy=1;
    19411999      solver->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
     2000      if (numberDown)
     2001        averageDown /= (double) numberDown;
     2002      else
     2003        averageDown=1.0;
     2004      if (numberUp)
     2005        averageUp /= (double) numberUp;
     2006      else
     2007        averageUp=1.0;
     2008      double weight;
     2009      if (!stateOfSearch)
     2010        weight=0.5;
     2011      else
     2012        weight=0.8;
     2013      double average = 0.5*(averageUp+averageDown);
     2014      int iDo;
     2015#define RANGING
     2016#ifdef RANGING
     2017      OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (solver);
     2018      if (osiclp&&iBestNot>=0) {
     2019        // just get those not touched and best and not trusted
     2020        int needed=0;
     2021        int * which = whichColumn+numberToDo+1;
     2022        int i;
     2023        for ( i=0;i<numberToDo;i++) {
     2024          if (whichColumn[i]>=0) {
     2025            which[needed++]=whichColumn[i];
     2026          }
     2027        }
     2028        which--;
     2029        which[0]=needed;
     2030        assert (needed);
     2031        osiclp->passInRanges(which);
     2032        // Mark hot start and get ranges
     2033        solver->markHotStart();
     2034        osiclp->passInRanges(NULL);
     2035        int put=0;
     2036        int get=0;
     2037        const double * downRange=osiclp->downRange();
     2038        const double * upRange=osiclp->upRange();;
     2039        int numberBeforeTrust = model->numberBeforeTrust();
     2040        for ( i=0;i<numberToDo;i++) {
     2041          int iObject = whichObject[i];
     2042          CbcObject * object = model->modifiableObject(iObject);
     2043          CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
     2044            dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
     2045          double estimate = sort[i];
     2046          bool keep=false;
     2047          if (i==iBestGot) {
     2048            // keep
     2049            keep=true;
     2050            estimate=-COIN_DBL_MAX;
     2051          } else {
     2052            int numberDown = dynamicObject->numberTimesDown();
     2053            int numberUp = dynamicObject->numberTimesUp();
     2054            if (numberDown<numberBeforeTrust||
     2055                numberUp<numberBeforeTrust) {
     2056              keep=true;
     2057              // make positive
     2058              estimate += best + 0.1*average*(2*numberBeforeTrust-numberUp-numberDown);
     2059              if (whichColumn[i]>=0) {
     2060                estimate = - (downRange[get]+upRange[get]);
     2061                get++;
     2062              }
     2063            }
     2064          }
     2065          if (keep) {
     2066            sort[put]=estimate;
     2067            whichObject[put++]=iObject;
     2068          }
     2069        }
     2070        numberToDo=put;
     2071      } else {
     2072        // Mark hot start
     2073        solver->markHotStart();
     2074        // make sure best will be first
     2075        if (iBestGot>=0)
     2076          sort[iBestGot]=-COIN_DBL_MAX;
     2077      }
     2078#else
    19422079      // Mark hot start
    19432080      solver->markHotStart();
    1944       int iDo=0;
     2081      // make sure best will be first
     2082      if (iBestGot>=0)
     2083        sort[iBestGot]=-COIN_DBL_MAX;
     2084#endif
     2085      // Sort
     2086      CoinSort_2(sort,sort+numberToDo,whichObject);
     2087      iDo=0;
     2088      int saveLimit2;
     2089      solver->getIntParam(OsiMaxNumIterationHotStart,saveLimit2);
    19452090      for ( iDo=0;iDo<numberToDo;iDo++) {
    19462091        CbcStrongInfo choice;
     
    19632108        if (model->messageHandler()->logLevel()>3)
    19642109          dynamicObject->print(1,choice.possibleBranch->value());
     2110        // was if (!canSkip)
    19652111        if (!canSkip) {
     2112          // just do a few
     2113          if (canSkip)
     2114            solver->setIntParam(OsiMaxNumIterationHotStart,10);
    19662115          double objectiveChange ;
    19672116          double newObjectiveValue=1.0e100;
     
    20972246          }
    20982247        }
     2248   
     2249        solver->setIntParam(OsiMaxNumIterationHotStart,saveLimit2);
    20992250        /*
    21002251          End of evaluation for this candidate variable. Possibilities are:
     
    21972348          printf("%d fixed\n",numberToFix);
    21982349        else
    2199           printf("choosing %d\n",bestChoice);
     2350          printf("choosing %d iDo %d numberToDo %d\n",bestChoice,whichChoice,numberToDo);
    22002351      }
    22012352      // Delete the snapshot
     
    22782429  delete [] sort;
    22792430  delete [] whichObject;
     2431  delete [] whichColumn;
    22802432  delete [] saveLower;
    22812433  delete [] saveUpper;
Note: See TracChangeset for help on using the changeset viewer.