Changeset 1249 for stable/1.8/Clp


Ignore:
Timestamp:
Jul 27, 2008 9:56:20 PM (12 years ago)
Author:
ladanyi
Message:

Updated stable/1.8 to match trunk

Location:
stable/1.8/Clp/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • stable/1.8/Clp/src/CbcOrClpParam.cpp

    r1214 r1249  
    15031503                  -COIN_DBL_MAX,COIN_DBL_MAX,DEXTRA4,false);
    15041504  parameters[numberParameters-1].setDoubleValue(0.0);
     1505  parameters[numberParameters++]=
     1506      CbcOrClpParam("Dins","Whether to try Distance Induced Neighborhood Search",
     1507                    "off",DINS);
     1508    parameters[numberParameters-1].append("on");
     1509    parameters[numberParameters-1].append("often");
     1510  parameters[numberParameters-1].setLonghelp
     1511    (
     1512     "This switches on Distance induced neighborhood Search."
     1513     );
    15051514#endif
    15061515  parameters[numberParameters++]=
     
    17091718  parameters[numberParameters-1].setLonghelp
    17101719    (
    1711      "If >0 then use some dubious scheme (for testing)"
    1712      );
    1713   parameters[numberParameters-1].setIntValue(-1);
     1720     "Defines how adventurous you want to be in using new ideas. \
     17210 then no new ideas, 1 fairly sensible, 2 a bit dubious, 3 you are on your own!"
     1722     );
     1723  parameters[numberParameters-1].setIntValue(0);
    17141724#endif
    17151725  parameters[numberParameters++]=
     
    17251735  parameters[numberParameters++]=
    17261736    CbcOrClpParam("extra1","Extra integer parameter 1",
    1727                   -100,COIN_INT_MAX,EXTRA1,false);
     1737                  -COIN_INT_MAX,COIN_INT_MAX,EXTRA1,false);
    17281738  parameters[numberParameters-1].setIntValue(-1);
    17291739  parameters[numberParameters++]=
    17301740    CbcOrClpParam("extra2","Extra integer parameter 2",
    1731                   -1,COIN_INT_MAX,EXTRA2,false);
     1741                  -100,COIN_INT_MAX,EXTRA2,false);
    17321742  parameters[numberParameters-1].setIntValue(-1);
    17331743  parameters[numberParameters++]=
     
    17831793    parameters[numberParameters-1].setLonghelp
    17841794    (
    1785      "-1 off.  If 0 then tries to branch to solution given by AMPL or priorities file. \
    1786 If >0 then also does that many nodes on fixed problem."
     1795     "-1 off.  If 1 then tries to branch to solution given by AMPL or priorities file. \
     1796If 0 then just tries to set as best solution \
     1797If 1 then also does that many nodes on fixed problem."
    17871798     );
    17881799#endif
     
    23742385  parameters[numberParameters-1].append("rows");
    23752386  parameters[numberParameters-1].append("all");
     2387  parameters[numberParameters-1].append("csv");
    23762388  parameters[numberParameters-1].setLonghelp
    23772389    (
  • stable/1.8/Clp/src/CbcOrClpParam.hpp

    r1209 r1249  
    8080    TWOMIRCUTS,PREPROCESS,FPUMP,GREEDY,COMBINE,LOCALTREE,SOS,
    8181    LANDPCUTS,RINS,RESIDCUTS,RENS,DIVINGS,DIVINGC,DIVINGF,DIVINGG,DIVINGL,
    82     DIVINGP,DIVINGV,
     82    DIVINGP,DIVINGV,DINS,
    8383   
    8484    DIRECTORY=301,DIRSAMPLE,DIRNETLIB,DIRMIPLIB,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,EITHERSIMPLEX,
  • stable/1.8/Clp/src/ClpMain.cpp

    r1236 r1249  
    16621662              }
    16631663              if (fp) {
     1664                // Write solution header (suggested by Luigi Poderico)
     1665                double objValue = models[iModel].getObjValue()*models[iModel].getObjSense();
     1666                int iStat = models[iModel].status();
     1667                if (iStat==0) {
     1668                  fprintf(fp, "optimal\n" );
     1669                } else if (iStat==1) {
     1670                  // infeasible
     1671                  fprintf(fp, "infeasible\n" );
     1672                } else if (iStat==2) {
     1673                  // unbounded
     1674                  fprintf(fp, "unbounded\n" );
     1675                } else if (iStat==3) {
     1676                  fprintf(fp, "stopped on iterations or time\n" );
     1677                } else if (iStat==4) {
     1678                  fprintf(fp, "stopped on difficulties\n" );
     1679                } else if (iStat==5) {
     1680                  fprintf(fp, "stopped on ctrl-c\n" );
     1681                } else {
     1682                  fprintf(fp, "status unknown\n" );
     1683                }
     1684                fprintf(fp, "Objective value %15.8g\n", objValue);
    16641685                // make fancy later on
    16651686                int iRow;
  • stable/1.8/Clp/src/ClpSimplex.cpp

    r1212 r1249  
    16731673    handler_->message()<<CoinMessageEol;
    16741674  }
     1675  //#define COMPUTE_INT_INFEAS
     1676#ifdef COMPUTE_INT_INFEAS
     1677  if (userPointer_) {
     1678    if (algorithm_>0&&integerType_&&!nonLinearCost_->numberInfeasibilities()) {
     1679      if (fabs(theta_)>1.0e-6||!numberIterations_) {
     1680        // For saving solutions
     1681        typedef struct {
     1682          int numberSolutions;
     1683          int maximumSolutions;
     1684          int numberColumns;
     1685          double ** solution;
     1686          int * numberUnsatisfied;
     1687        } clpSolution;
     1688        clpSolution * solution = (clpSolution *) userPointer_;
     1689        if (solution->numberSolutions==solution->maximumSolutions) {
     1690          int n =  solution->maximumSolutions;
     1691          int n2 = (n*3)/2+10;
     1692          solution->maximumSolutions=n2;
     1693          double ** temp = new double * [n2];
     1694          for (int i=0;i<n;i++)
     1695            temp[i]=solution->solution[i];
     1696          delete [] solution->solution;
     1697          solution->solution=temp;
     1698          int * tempN = new int [n2];
     1699          for (int i=0;i<n;i++)
     1700            tempN[i] = solution->numberUnsatisfied[i];
     1701          delete [] solution->numberUnsatisfied;
     1702          solution->numberUnsatisfied = tempN;
     1703        }
     1704        assert (numberColumns_==solution->numberColumns);
     1705        double * sol = new double [numberColumns_];
     1706        solution->solution[solution->numberSolutions]=sol;
     1707        int numberFixed=0;
     1708        int numberUnsat=0;
     1709        int numberSat=0;
     1710        double sumUnsat=0.0;
     1711        double tolerance = 10.0*primalTolerance_;
     1712        double mostAway=0.0;
     1713        int iAway=-1;
     1714        for (int i=0;i<numberColumns_;i++) {
     1715          // Save anyway
     1716          sol[i] = columnScale_ ? solution_[i]*columnScale_[i] : solution_[i];
     1717          // rest is optional
     1718          if (upper_[i]>lower_[i]) {
     1719            double value = solution_[i];
     1720            if (value>lower_[i]+tolerance&&
     1721                value<upper_[i]-tolerance&&integerType_[i]) {
     1722              // may have to modify value if scaled
     1723              if (columnScale_)
     1724                value *= columnScale_[i];
     1725              double closest = floor(value+0.5);
     1726              // problem may be perturbed so relax test
     1727              if (fabs(value-closest)>1.0e-4) {
     1728                numberUnsat++;
     1729                sumUnsat += fabs(value-closest);
     1730                if (mostAway<fabs(value-closest)) {
     1731                  mostAway=fabs(value-closest);
     1732                  iAway=i;
     1733                }
     1734              } else {
     1735                numberSat++;
     1736              }
     1737            } else {
     1738              numberSat++;
     1739            }
     1740          } else {
     1741            numberFixed++;
     1742          }
     1743        }
     1744        solution->numberUnsatisfied[solution->numberSolutions++]=numberUnsat;
     1745        printf("iteration %d, %d unsatisfied (%g,%g), %d fixed, %d satisfied\n",
     1746               numberIterations_,numberUnsat,sumUnsat,mostAway,numberFixed,numberSat);
     1747      }
     1748    }
     1749  }
     1750#endif
    16751751  if (hitMaximumIterations())
    16761752    return 2;
     
    53695445    // Allow for catastrophe
    53705446    int saveMax = intParam_[ClpMaxNumIteration];
    5371     if (intParam_[ClpMaxNumIteration]>100000+numberIterations_)
    5372       intParam_[ClpMaxNumIteration] = numberIterations_ + 1000 + 2*numberRows_+numberColumns_;
     5447    if (numberIterations_) {
     5448      // normal
     5449      if (intParam_[ClpMaxNumIteration]>100000+numberIterations_)
     5450        intParam_[ClpMaxNumIteration]
     5451          = numberIterations_ + 1000 + 2*numberRows_+numberColumns_;
     5452    } else {
     5453      // Not normal allow more
     5454      baseIteration_ += 2*(numberRows_+numberColumns_);
     5455    }
    53735456    // check which algorithms allowed
    53745457    int dummy;
  • stable/1.8/Clp/src/ClpSimplexDual.cpp

    r1201 r1249  
    227227  // If user asked for perturbation - do it
    228228  if (!startup(0,startFinishOptions)) {
     229    int usePrimal=0;
    229230    // looks okay
    230231    // Superbasic variables not allowed
     
    232233    if (ifValuesPass) {
    233234      if (problemStatus_&&perturbation_<100)
    234         perturb();
     235        usePrimal=perturb();
    235236      int i;
    236237      if (scalingFlag_>0) {
     
    304305      bool inCbcOrOther = (specialOptions_&0x03000000)!=0;
    305306      if (!inCbcOrOther)
    306         perturb();
     307        usePrimal=perturb();
    307308      // Can't get here if values pass
    308309      gutsOfSolution(NULL,NULL);
     
    321322      if (inCbcOrOther) {
    322323        if (numberPrimalInfeasibilities_) {
    323           perturb();
     324          usePrimal=perturb();
    324325          if (perturbation_>=101)
    325326            computeDuals(NULL);
     
    337338      gutsOfSolution(NULL,NULL);
    338339    }
    339     return 0;
     340    if (usePrimal) {
     341      problemStatus_=10;
     342#if COIN_DEVELOP>1
     343      printf("returning to use primal (no obj) at %d\n",__LINE__);
     344#endif
     345    }
     346    return usePrimal;
    340347  } else {
    341348    return 1;
     
    45184525}
    45194526// Perturbs problem
    4520 void
     4527int
    45214528ClpSimplexDual::perturb()
    45224529{
    45234530  if (perturbation_>100)
    4524     return; //perturbed already
     4531    return 0; //perturbed already
    45254532  if (perturbation_==100)
    45264533    perturbation_=50; // treat as normal
     
    45744581    }
    45754582    delete [] sort;
     4583    if (!numberNonZero)
     4584      return 1; // safer to use primal
    45764585#if 0
    45774586    printf("nnz %d percent %d",number,(number*100)/numberColumns_);
     
    45884597    if (number*4>numberColumns_) {
    45894598      perturbation_=100;
    4590       return; // good enough
     4599      return 0; // good enough
    45914600    }
    45924601  }
     
    48614870  // say perturbed
    48624871  perturbation_=101;
    4863 
     4872  return 0;
    48644873}
    48654874/* For strong branching.  On input lower and upper are new bounds
  • stable/1.8/Clp/src/ClpSimplexDual.hpp

    r1034 r1249  
    266266                             double * givenDjs, ClpDataSave & saveData,
    267267                             int ifValuesPass);
    268   /// Perturbs problem (method depends on perturbation())
    269   void perturb();
     268  /** Perturbs problem (method depends on perturbation())
     269      returns nonzero if should go to dual */
     270  int perturb();
    270271  /** Fast iterations.  Misses out a lot of initialization.
    271272      Normally stops on maximum iterations, first re-factorization
Note: See TracChangeset for help on using the changeset viewer.