Changeset 1054 for trunk/Clp


Ignore:
Timestamp:
Jul 24, 2007 3:52:28 PM (13 years ago)
Author:
forrest
Message:

changes to compile under gcc 4.3

Location:
trunk/Clp/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/CbcOrClpParam.cpp

    r1034 r1054  
    15041504  parameters[numberParameters++]=
    15051505    CbcOrClpParam("extra1","Extra integer parameter 1",
    1506                   -1,INT_MAX,EXTRA1,false);
     1506                  -1,COIN_INT_MAX,EXTRA1,false);
    15071507  parameters[numberParameters-1].setIntValue(-1);
    15081508  parameters[numberParameters++]=
    15091509    CbcOrClpParam("extra2","Extra integer parameter 2",
    1510                   -1,INT_MAX,EXTRA2,false);
     1510                  -1,COIN_INT_MAX,EXTRA2,false);
    15111511  parameters[numberParameters-1].setIntValue(-1);
    15121512  parameters[numberParameters++]=
    15131513    CbcOrClpParam("extra3","Extra integer parameter 3",
    1514                   -1,INT_MAX,EXTRA3,false);
     1514                  -1,COIN_INT_MAX,EXTRA3,false);
    15151515  parameters[numberParameters-1].setIntValue(-1);
    15161516  parameters[numberParameters++]=
    15171517    CbcOrClpParam("extra4","Extra integer parameter 4",
    1518                   -1,INT_MAX,EXTRA4,false);
     1518                  -1,COIN_INT_MAX,EXTRA4,false);
    15191519  parameters[numberParameters-1].setIntValue(-1);
    15201520#endif
     
    16221622  parameters[numberParameters++]=
    16231623    CbcOrClpParam("hot!StartMaxIts","Maximum iterations on hot start",
    1624                   0,INT_MAX,MAXHOTITS,false);
     1624                  0,COIN_INT_MAX,MAXHOTITS,false);
    16251625#endif
    16261626#ifdef COIN_HAS_CLP
     
    18091809  parameters[numberParameters++]=
    18101810    CbcOrClpParam("mipO!ptions","Dubious options for mip",
    1811                   0,INT_MAX,MIPOPTIONS,false);
     1811                  0,COIN_INT_MAX,MIPOPTIONS,false);
    18121812  parameters[numberParameters++]=
    18131813    CbcOrClpParam("more!MipOptions","More dubious options for mip",
    1814                   -1,INT_MAX,MOREMIPOPTIONS,false);
     1814                  -1,COIN_INT_MAX,MOREMIPOPTIONS,false);
    18151815  parameters[numberParameters++]=
    18161816    CbcOrClpParam("mixed!IntegerRoundingCuts","Whether to use Mixed Integer Rounding cuts",
     
    18401840  parameters[numberParameters++]=
    18411841    CbcOrClpParam("miniT!ree","Size of fast mini tree",
    1842                   0,INT_MAX,NUMBERMINI,false);
     1842                  0,COIN_INT_MAX,NUMBERMINI,false);
    18431843  parameters[numberParameters-1].setLonghelp
    18441844    (
     
    19221922  parameters[numberParameters++]=
    19231923    CbcOrClpParam("numberA!nalyze","Number of analysis iterations",
    1924                   -INT_MAX,INT_MAX,NUMBERANALYZE,false);
     1924                  -COIN_INT_MAX,COIN_INT_MAX,NUMBERANALYZE,false);
    19251925  parameters[numberParameters-1].setLonghelp
    19261926    (
     
    20282028  parameters[numberParameters++]=
    20292029    CbcOrClpParam("pO!ptions","Dubious print options",
    2030                   0,INT_MAX,PRINTOPTIONS,false);
     2030                  0,COIN_INT_MAX,PRINTOPTIONS,false);
    20312031  parameters[numberParameters-1].setIntValue(0);
    20322032  parameters[numberParameters-1].setLonghelp
     
    20362036  parameters[numberParameters++]=
    20372037    CbcOrClpParam("preO!pt","Presolve options",
    2038                   0,INT_MAX,PRESOLVEOPTIONS,false);
     2038                  0,COIN_INT_MAX,PRESOLVEOPTIONS,false);
    20392039#endif
    20402040  parameters[numberParameters++]=
     
    24372437  parameters[numberParameters++]=
    24382438    CbcOrClpParam("special!Options","Dubious options for Simplex - see ClpSimplex.hpp",
    2439                   0,INT_MAX,SPECIALOPTIONS,false);
     2439                  0,COIN_INT_MAX,SPECIALOPTIONS,false);
    24402440  parameters[numberParameters++]=
    24412441    CbcOrClpParam("sprint!Crash","Whether to try sprint crash",
     
    24992499  parameters[numberParameters++]=
    25002500    CbcOrClpParam("testO!si","Test OsiObject stuff",
    2501                   -1,INT_MAX,TESTOSI,false);
     2501                  -1,COIN_INT_MAX,TESTOSI,false);
    25022502#endif
    25032503#ifdef CBC_THREAD
  • trunk/Clp/src/ClpGubDynamicMatrix.cpp

    r1034 r1054  
    10521052  memset(mark,0,numberColumns);
    10531053  for (int iColumn=0;iColumn<numberColumns;iColumn++)
    1054     next_[iColumn]=INT_MAX;
     1054    next_[iColumn]=COIN_INT_MAX;
    10551055  int i;
    10561056  int * keys = new int[numberSets_];
     
    10581058  CoinFillN(back,numberGubColumns_,-1);
    10591059  for (i=0;i<numberSets_;i++)
    1060     keys[i]=INT_MAX;
     1060    keys[i]=COIN_INT_MAX;
    10611061  delete [] dynamicStatus_;
    10621062  dynamicStatus_ = new unsigned char [numberGubColumns_];
     
    11021102    double value=0.0;
    11031103    j=keys[iSet];
    1104     while (j!=INT_MAX) {
     1104    while (j!=COIN_INT_MAX) {
    11051105      if (model->getStatus(j)== ClpSimplex::basic) {
    11061106        if (length[j]<smallest) {
     
    14371437  memset(mark,0,numberColumns);
    14381438  for (int iColumnX=0;iColumnX<firstAvailable_;iColumnX++)
    1439     next_[iColumnX]=INT_MAX;
     1439    next_[iColumnX]=COIN_INT_MAX;
    14401440  for (i=0;i<numberSets_;i++) {
    1441     keys[i]=INT_MAX;
     1441    keys[i]=COIN_INT_MAX;
    14421442    int iKey = keyVariable_[i];
    14431443    if (iKey<numberColumns)
     
    14561456  }
    14571457  for (i=0;i<numberSets_;i++) {
    1458     if (keys[i]!=INT_MAX) {
     1458    if (keys[i]!=COIN_INT_MAX) {
    14591459      // something in set
    14601460      int j;
     
    14721472            smallest=length[j];
    14731473          }
    1474           if (next_[j]!=INT_MAX) {
     1474          if (next_[j]!=COIN_INT_MAX) {
    14751475            j = next_[j];
    14761476          } else {
     
    14961496        while (1) {
    14971497          sol += columnSolution[j];
    1498           if (next_[j]!=INT_MAX) {
     1498          if (next_[j]!=COIN_INT_MAX) {
    14991499            j = next_[j];
    15001500          } else {
  • trunk/Clp/src/ClpGubMatrix.cpp

    r1034 r1054  
    33683368  memset(mark,0,numberColumns);
    33693369  for (int iColumn=0;iColumn<numberColumns;iColumn++)
    3370     next_[iColumn]=INT_MAX;
     3370    next_[iColumn]=COIN_INT_MAX;
    33713371  int i;
    33723372  int * keys = new int[numberSets_];
    33733373  for (i=0;i<numberSets_;i++)
    3374     keys[i]=INT_MAX;
     3374    keys[i]=COIN_INT_MAX;
    33753375  // set up chains
    33763376  for (i=0;i<numberColumns;i++){
     
    33943394      int key=-1;
    33953395      j = keys[i];
    3396       if (j!=INT_MAX) {
     3396      if (j!=COIN_INT_MAX) {
    33973397        while (1) {
    33983398          if (mark[j]&&columnLength[j]<smallest&&!gotBasis) {
     
    34003400            smallest=columnLength[j];
    34013401          }
    3402           if (next_[j]!=INT_MAX) {
     3402          if (next_[j]!=COIN_INT_MAX) {
    34033403            j = next_[j];
    34043404          } else {
     
    34273427      double sol=0.0;
    34283428      j = keys[i];
    3429       if (j!=INT_MAX) {
     3429      if (j!=COIN_INT_MAX) {
    34303430        while (1) {
    34313431          sol += columnSolution[j];
    3432           if (next_[j]!=INT_MAX) {
     3432          if (next_[j]!=COIN_INT_MAX) {
    34333433            j = next_[j];
    34343434          } else {
  • trunk/Clp/src/ClpMessage.hpp

    r1034 r1054  
    66
    77#include "CoinPragma.hpp"
     8#include <cstring>
    89
    910// This deals with Clp messages (as against Osi messages etc)
  • trunk/Clp/src/ClpSimplexNonlinear.cpp

    r1034 r1054  
    33503350  //const double * elementByRow = copy.getElements();
    33513351  int numberArtificials=0;
     3352  // We could use nonlinearcost to do segments - maybe later
     3353#define SEGMENTS 3 
    33523354  // see how many extra we need
    33533355  CoinBigIndex numberExtra=0;
     
    33833385  }
    33843386  int numberColumns2 = numberColumns_;
    3385   double penalty=1.0e9;
     3387  // Penalties may be adjusted by duals
     3388  // Both these should be modified depending on problem
     3389  double penalties[]={1.0e-2,1.0,1.0e9};
     3390  double bounds[] = {1.0e-2,1.0,COIN_DBL_MAX};
    33863391  if (numberArtificials) {
     3392    numberArtificials *= SEGMENTS;
    33873393    numberColumns2 += numberArtificials;
    33883394    int * addStarts = new int [numberArtificials+1];
    33893395    int * addRow = new int[numberArtificials];
    33903396    double * addElement = new double[numberArtificials];
     3397    double * addUpper = new double[numberArtificials];
    33913398    addStarts[0]=0;
    33923399    double * addCost = new double [numberArtificials];
     
    33963403      int iRow = constraint->rowNumber();
    33973404      if (rowLower_[iRow]>-1.0e20) {
    3398         addRow[numberArtificials]=iRow;
    3399         addElement[numberArtificials]=1.0;
    3400         addCost[numberArtificials]=penalty;
    3401         numberArtificials++;
    3402         addStarts[numberArtificials]=numberArtificials;
     3405        for (int k=0;k<SEGMENTS;k++) {
     3406          addRow[numberArtificials]=iRow;
     3407          addElement[numberArtificials]=1.0;
     3408          addCost[numberArtificials]=penalties[k];
     3409          addUpper[numberArtificials]=bounds[k];
     3410          numberArtificials++;
     3411          addStarts[numberArtificials]=numberArtificials;
     3412        }
    34033413      }
    34043414      if (rowUpper_[iRow]<1.0e20) {
    3405         addRow[numberArtificials]=iRow;
    3406         addElement[numberArtificials]=-1.0;
    3407         addCost[numberArtificials]=penalty;
    3408         numberArtificials++;
    3409         addStarts[numberArtificials]=numberArtificials;
    3410       }
    3411     }
    3412     newModel.addColumns(numberArtificials,NULL,NULL,addCost,
     3415        for (int k=0;k<SEGMENTS;k++) {
     3416          addRow[numberArtificials]=iRow;
     3417          addElement[numberArtificials]=-1.0;
     3418          addCost[numberArtificials]=penalties[k];
     3419          addUpper[numberArtificials]=bounds[k];
     3420          numberArtificials++;
     3421          addStarts[numberArtificials]=numberArtificials;
     3422        }
     3423      }
     3424    }
     3425    newModel.addColumns(numberArtificials,NULL,addUpper,addCost,
    34133426                       addStarts,addRow,addElement);
    34143427    delete [] addStarts;
    34153428    delete [] addRow;
    34163429    delete [] addElement;
     3430    delete [] addUpper;
    34173431    delete [] addCost;
    34183432  }
     
    34703484      int numberArtificials=0;
    34713485      if (rowLower_[iRow]>-1.0e20)
    3472         numberArtificials++;
     3486        numberArtificials += SEGMENTS;
    34733487      if (rowUpper_[iRow]<1.0e20)
    3474         numberArtificials++;
     3488        numberArtificials += SEGMENTS;
    34753489      if (numberArtificials==rowLength[iRow]) {
    34763490        // all possible
     
    36833697      objValue=objective_->objectiveValue(this,solution);
    36843698    }
     3699    double infPenalty=0.0;
    36853700    for (iConstraint=0;iConstraint<numberConstraints;iConstraint++) {
    36863701      ClpConstraint * constraint = constraints[iConstraint];
     
    36923707               newModel.primalRowSolution()[iRow],
    36933708               dualValue,offset);
     3709      double infeasibility=0.0;
    36943710      if (functionValue<rowLower_[iRow]-1.0e-5) {
    3695         double under = rowLower_[iRow]-functionValue;
    3696         infValue += under;
     3711        infeasibility = rowLower_[iRow]-functionValue;
    36973712      } else if (functionValue>rowUpper_[iRow]+1.0e-5) {
    3698         double over = functionValue-rowUpper_[iRow];
    3699         infValue += over;
     3713        infeasibility = functionValue-rowUpper_[iRow];
     3714      }
     3715      infValue += infeasibility;
     3716      for (int k=0;k<SEGMENTS;k++) {
     3717        if (infeasibility<=0)
     3718          break;
     3719        double thisPart = CoinMin(infeasibility,bounds[k]);
     3720        infPenalty += thisPart*penalties[k];
     3721        infeasibility -= thisPart;
    37003722      }
    37013723    }
    37023724    if (infValue)
    3703       printf("Sum infeasibilities %g ",infValue);
    3704     if (infValue<0.1)
    3705       infValue=0.0;
    3706     infValue *= penalty;
    3707     if (infValue)
    3708       printf("Infeasible obj %g ",infValue);
     3725      printf("Sum infeasibilities %g - penalty %g",infValue,infPenalty);
    37093726    if (objectiveOffset2)
    37103727      printf("offset2 %g\n",objectiveOffset2);
    37113728    objValue -= objectiveOffset2;
    37123729    printf("True objective %g\n",objValue);
    3713     objValue += infValue;
     3730    objValue += infPenalty;
    37143731    if (iPass) {
    37153732      double drop = lastObjective-objValue;
  • trunk/Clp/src/Idiot.cpp

    r1034 r1054  
    909909         if (lambdaIteration>4 &&
    910910            (((lambdaIteration%10)==0 && smallInfeas<keepinfeas) ||
    911              (lambdaIteration%5)==0 && 1.5*smallInfeas<keepinfeas)) {
     911             ((lambdaIteration%5)==0 && 1.5*smallInfeas<keepinfeas))) {
    912912           //printf(" Increasing smallInfeas from %f to %f\n",smallInfeas,1.5*smallInfeas);
    913913           smallInfeas *= 1.5;
Note: See TracChangeset for help on using the changeset viewer.