Changeset 1929


Ignore:
Timestamp:
Apr 6, 2013 11:30:55 AM (6 years ago)
Author:
stefan
Message:

fix compiler (gcc 4.6.2) warnings in optimized mode, mainly about unused variables

Location:
trunk/Clp/src
Files:
10 edited

Legend:

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

    r1723 r1929  
    4444     mumps_->sym = 2;//general symmetric matrix
    4545     mumps_->comm_fortran = USE_COMM_WORLD;
    46      int myid, ierr;
     46     int myid;
    4747     int justName;
    48      ierr = MPI_Init(&justName, NULL);
    49      ierr = MPI_Comm_rank(MPI_COMM_WORLD, &myid);
     48     MPI_Init(&justName, NULL);
     49#ifndef NDEBUG
     50     int ierr = MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    5051     assert (!ierr);
     52#else
     53     MPI_Comm_rank(MPI_COMM_WORLD, &myid);
     54#endif
    5155     dmumps_c(mumps_);
    5256#define ICNTL(I) icntl[(I)-1] /* macro s.t. indices match documentation */
     
    301305     const double * diagonalSlack = diagonal + numberColumns;
    302306     int newDropped = 0;
    303      double largest;
    304307     //double smallest;
    305308     //perturbation
     
    360363     double largest2 = maximumAbsElement(sparseFactor_, sizeFactor_);
    361364     largest2 *= 1.0e-20;
    362      largest = CoinMin(largest2, 1.0e-11);
    363365     int numberDroppedBefore = 0;
    364366     for (iRow = 0; iRow < numberRows_; iRow++) {
  • trunk/Clp/src/ClpGubMatrix.cpp

    r1732 r1929  
    21162116          int i;
    21172117          double * solution = model->solutionRegion();
    2118           ClpSimplex::Status iStatus;
    21192118          //const int * columnLength = matrix_->getVectorLengths();
    21202119          //const CoinBigIndex * columnStart = matrix_->getVectorStarts();
     
    21672166               } else {
    21682167                    // slack is key
    2169                     iStatus = getStatus(i);
    2170                     assert (iStatus == ClpSimplex::basic);
     2168                    assert (getStatus(i) == ClpSimplex::basic);
    21712169                    double infeasibility = 0.0;
    21722170                    if (value > upper_[i] + primalTolerance) {
     
    22172215          int i;
    22182216          double * cost = model->costRegion();
    2219           ClpSimplex::Status iStatus;
    22202217          // not dual values yet
    22212218          //assert (!other);
     
    22372234                         } else {
    22382235                              // slack is key
    2239                               iStatus = getStatus(iSet);
    2240                               assert (iStatus == ClpSimplex::basic);
     2236                              assert (getStatus(iSet) == ClpSimplex::basic);
    22412237                              // negative as -1.0 for slack
    22422238                              costValue = -weight(iSet) * infeasibilityCost;
  • trunk/Clp/src/ClpMain.cpp

    r1926 r1929  
    918918                                        // if infeasible check ray
    919919                                        if (model2->status()==1) {
    920                                           int debugMode=0;
    921920                                          ClpSimplex * simplex = model2;
    922921                                          if(simplex->ray()) {
  • trunk/Clp/src/ClpPredictorCorrector.cpp

    r1926 r1929  
    6767static CoinWorkDouble eBaseCaution = 1.0e-12;
    6868static CoinWorkDouble eBase = 1.0e-12;
    69 static CoinWorkDouble eRatio = 1.0e40;
    70 static CoinWorkDouble eRatioCaution = 1.0e25;
    7169static CoinWorkDouble eDiagonal = 1.0e25;
    7270static CoinWorkDouble eDiagonalCaution = 1.0e18;
     
    225223     CoinWorkDouble * saveSU = new CoinWorkDouble[numberTotal];
    226224     // Save smallest mu used in primal dual moves
    227      CoinWorkDouble smallestPrimalDualMu = COIN_DBL_MAX;
    228225     CoinWorkDouble objScale = optimizationDirection_ /
    229226                               (rhsScale_ * objectiveScale_);
     
    778775               }
    779776               mu_ = complementarityGap_ / phi;
    780                //printf("pd mu %g, alternate %g, smallest %g\n",
    781                //     mu_,mu1,smallestPrimalDualMu);
     777               //printf("pd mu %g, alternate %g, smallest\n",mu_,mu1);
    782778               mu_ = CoinSqrt(mu_ * mu1);
    783779               mu_ = mu1;
    784780               if ((numberIterations_ & 1) == 0 || numberIterations_ < 10)
    785781                    mu_ = saveMu;
    786                //mu_=CoinMin(smallestPrimalDualMu*0.95,mu_);
    787                smallestPrimalDualMu = mu_;
    788782               // Try simpler
    789783               floatNumber = numberComplementarityItems_;
     
    818812               }
    819813          }
    820           if (numberIterations_ == 0)
    821                smallestPrimalDualMu = mu_;
    822814          if (!goodMove)
    823815               mu_ = nextGap / (static_cast<CoinWorkDouble> (nextNumber) * 1.1);
     
    827819          // Do centering steps
    828820          int numberTries = 0;
    829           CoinWorkDouble nextCenterGap = 0.0;
    830821          int numberGoodTries = 0;
    831822#ifdef COIN_DETAIL
     823          CoinWorkDouble nextCenterGap = 0.0;
    832824          CoinWorkDouble originalDualStep = actualDualStep_;
    833825          CoinWorkDouble originalPrimalStep = actualPrimalStep_;
     
    883875#endif
    884876                    numberGoodTries++;
     877#ifdef COIN_DETAIL
    885878                    nextCenterGap = xGap;
     879#endif
    886880                    // See if big enough change
    887881                    if (actualPrimalStep_ < 1.01 * checkPrimal ||
     
    10091003     int numberTotal = numberRows_ + numberColumns_;
    10101004     CoinWorkDouble tolerance = 1.0e-12;
     1005#ifdef SOME_DEBUG
    10111006     int chosenPrimalSequence = -1;
    10121007     int chosenDualSequence = -1;
    10131008     bool lowPrimal = false;
    10141009     bool lowDual = false;
     1010#endif
    10151011     // If done many iterations then allow to hit boundary
    10161012     CoinWorkDouble hitTolerance;
     
    10361032                         if (zVec_[iColumn] < -z1 * maximumDualStep) {
    10371033                              maximumDualStep = -zVec_[iColumn] / z1;
     1034#ifdef SOME_DEBUG
    10381035                              chosenDualSequence = iColumn;
    10391036                              lowDual = true;
     1037#endif
    10401038                         }
    10411039                    }
     
    10441042                         if (newStep > 0.2 || newZ < hitTolerance || delta > 1.0e3 || delta <= 1.0e-6 || dj_[iColumn] < hitTolerance) {
    10451043                              maximumPrimalStep = newStep;
     1044#ifdef SOME_DEBUG
    10461045                              chosenPrimalSequence = iColumn;
    10471046                              lowPrimal = true;
     1047#endif
    10481048                         } else {
    10491049                              //printf("small %d delta %g newZ %g step %g\n",iColumn,delta,newZ,newStep);
     
    10581058                         if (wVec_[iColumn] < -w1 * maximumDualStep) {
    10591059                              maximumDualStep = -wVec_[iColumn] / w1;
     1060#ifdef SOME_DEBUG
    10601061                              chosenDualSequence = iColumn;
    10611062                              lowDual = false;
     1063#endif
    10621064                         }
    10631065                    }
     
    10661068                         if (newStep > 0.2 || newT < hitTolerance || delta > 1.0e3 || delta <= 1.0e-6 || dj_[iColumn] > -hitTolerance) {
    10671069                              maximumPrimalStep = newStep;
     1070#ifdef SOME_DEBUG
    10681071                              chosenPrimalSequence = iColumn;
    10691072                              lowPrimal = false;
     1073#endif
    10701074                         } else {
    10711075                              //printf("small %d delta %g newT %g step %g\n",iColumn,delta,newT,newStep);
     
    23792383               numberComplementarityPairs++;
    23802384               //can collapse as if no lower bound both zVec and deltaZ 0.0
    2381                CoinWorkDouble newZ = 0.0;
    2382                CoinWorkDouble newW = 0.0;
    23832385               if (lowerBound(iColumn)) {
    23842386                    numberComplementarityItems++;
     
    23922394                         change = solution_[iColumn] + deltaX_[iColumn] - lowerSlack_[iColumn] - lower_[iColumn];
    23932395                         dualValue = zVec_[iColumn] + actualDualStep_ * deltaZ_[iColumn];
    2394                          newZ = dualValue;
    23952396                         primalValue = lowerSlack_[iColumn] + actualPrimalStep_ * change;
    23962397                    }
     
    24292430                         change = upper_[iColumn] - solution_[iColumn] - deltaX_[iColumn] - upperSlack_[iColumn];
    24302431                         dualValue = wVec_[iColumn] + actualDualStep_ * deltaW_[iColumn];
    2431                          newW = dualValue;
    24322432                         primalValue = upperSlack_[iColumn] + actualPrimalStep_ * change;
    24332433                    }
     
    31093109     CoinWorkDouble offsetObjective = 0.0;
    31103110     CoinWorkDouble killTolerance = primalTolerance();
    3111      CoinWorkDouble qDiagonal;
    3112      if (mu_ < 1.0) {
    3113           qDiagonal = 1.0e-8;
    3114      } else {
    3115           qDiagonal = 1.0e-8 * mu_;
    3116      }
    31173111     //CoinWorkDouble nextMu = nextGap/(static_cast<CoinWorkDouble>(2*numberComplementarityPairs_));
    31183112     //printf("using gap of %g\n",nextMu);
    3119      //qDiagonal *= 1.0e2;
    31203113     //largest allowable ratio of lowerSlack/zVec (etc)
    3121      CoinWorkDouble largestRatio;
    31223114     CoinWorkDouble epsilonBase;
    31233115     CoinWorkDouble diagonalLimit;
    31243116     if (!caution) {
    31253117          epsilonBase = eBase;
    3126           largestRatio = eRatio;
    31273118          diagonalLimit = eDiagonal;
    31283119     } else {
    31293120          epsilonBase = eBaseCaution;
    3130           largestRatio = eRatioCaution;
    31313121          diagonalLimit = eDiagonalCaution;
    31323122     }
    3133      CoinWorkDouble smallGap = 1.0e2;
    31343123     CoinWorkDouble maximumDJInfeasibility = 0.0;
    31353124     int numberIncreased = 0;
     
    33053294                    CoinWorkDouble feasibleSlack = newPrimal - lower_[iColumn];
    33063295                    if (feasibleSlack > 0.0 && newSlack > 0.0) {
    3307                          CoinWorkDouble smallGap2 = smallGap;
    3308                          if (CoinAbs(0.1 * newPrimal) > smallGap) {
    3309                               smallGap2 = 0.1 * CoinAbs(newPrimal);
    3310                          }
    33113296                         CoinWorkDouble larger;
    33123297                         if (newSlack > feasibleSlack) {
     
    33633348                    CoinWorkDouble feasibleSlack = upper_[iColumn] - newPrimal;
    33643349                    if (feasibleSlack > 0.0 && newSlack > 0.0) {
    3365                          CoinWorkDouble smallGap2 = smallGap;
    3366                          if (CoinAbs(0.1 * newPrimal) > smallGap) {
    3367                               smallGap2 = 0.1 * CoinAbs(newPrimal);
    3368                          }
    33693350                         CoinWorkDouble larger;
    33703351                         if (newSlack > feasibleSlack) {
     
    39313912     }
    39323913     primalObjectiveNew -= primalOffset * scaleFactor_;
    3933      CoinWorkDouble maximumRHSError;
     3914     //CoinWorkDouble maximumRHSError;
    39343915     if (maximumRHSError1 > maximumRHSError2) {
    3935           maximumRHSError = maximumRHSError1;
     3916          ;//maximumRHSError = maximumRHSError1;
    39363917     } else {
    3937           maximumRHSError = maximumRHSError1; //note change
     3918          //maximumRHSError = maximumRHSError1; //note change
    39383919          if (maximumRHSError2 > primalTolerance()) {
    39393920               handler_->message(CLP_BARRIER_ABS_DROPPED, messages_)
  • trunk/Clp/src/ClpPresolve.cpp

    r1926 r1929  
    704704          double newLower=COIN_DBL_MAX;
    705705          double newUpper=-COIN_DBL_MAX;
     706#ifdef PRINT_VALUES
    706707          double ranges0[2];
    707708          double ranges1[2];
     709#endif
    708710          double costEqual;
    709711          double slope[2];
     
    719721          costEqual = xValue*cost[otherCol]+yValueEqual*cost[icol];
    720722          if (binding0==1) {
     723#ifdef PRINT_VALUES
    721724            ranges0[0]=bound[0];
    722725            ranges0[1]=yValue0;
    723726            ranges1[0]=yValue0;
    724727            ranges1[1]=bound[1];
     728#endif
    725729            // take x 1.0 down
    726730            double x=xValue-1.0;
     
    734738            slope[1] = costTotal-costEqual;
    735739          } else {
     740#ifdef PRINT_VALUES
    736741            ranges1[0]=bound[0];
    737742            ranges1[1]=yValue0;
    738743            ranges0[0]=yValue0;
    739744            ranges0[1]=bound[1];
     745#endif
    740746            // take x 1.0 down
    741747            double x=xValue-1.0;
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1926 r1929  
    32873287     //newTolerance = dualTolerance_+1.0e-6*dblParam_[ClpDualTolerance];
    32883288     // will we need to increase tolerance
    3289      bool thisIncrease = false;
     3289     //bool thisIncrease = false;
    32903290     // If we think we need to modify costs (not if something from broad sweep)
    32913291     bool modifyCosts = false;
     
    38113811                              //at upper bound
    38123812                              if (value > dualTolerance_) {
    3813                                    thisIncrease = true;
     3813                                   //thisIncrease = true;
    38143814#if CLP_CAN_HAVE_ZERO_OBJ<2
    38153815#define MODIFYCOST 2
     
    38413841                              // at lower bound
    38423842                              if (-value > dualTolerance_) {
    3843                                    thisIncrease = true;
     3843                                   //thisIncrease = true;
    38443844#if MODIFYCOST
    38453845                                   // modify cost to hit new tolerance
  • trunk/Clp/src/ClpSimplexNonlinear.cpp

    r1924 r1929  
    332332     }
    333333     // Flag to say whether to go to dual to clean up
    334      bool goToDual = false;
     334     //bool goToDual = false;
    335335     // really for free variables in
    336336     //if((progressFlag_&2)!=0)
     
    417417                    if ((infeasibilityCost_ >= 1.0e18 ||
    418418                              numberDualInfeasibilities_ == 0) && perturbation_ == 101) {
    419                          goToDual = unPerturb(); // stop any further perturbation
     419                         /* goToDual = unPerturb(); // stop any further perturbation
    420420                         if (nonLinearCost_->sumInfeasibilities() > 1.0e-1)
    421421                              goToDual = false;
     422                         */
     423                         unPerturb();
    422424                         nonLinearCost_->checkInfeasibilities(primalTolerance_);
    423425                         numberDualInfeasibilities_ = 1; // carry on
     
    454456                         gutsOfSolution(NULL, NULL, true);
    455457                         problemStatus_ = -1; //continue
    456                          goToDual = false;
     458                         //goToDual = false;
    457459                    } else {
    458460                         // say infeasible
     
    463465               // may be optimal
    464466               if (perturbation_ == 101) {
    465                     goToDual = unPerturb(); // stop any further perturbation
     467                    /* goToDual =*/ unPerturb(); // stop any further perturbation
    466468                    lastCleaned = -1; // carry on
    467469               }
     
    13521354                    matrix_->times(1.0, solution_, rhs, rowScale_, columnScale_);
    13531355                    double largest = 0.0;
     1356#if CLP_DEBUG > 0
    13541357                    int iLargest = -1;
     1358#endif
    13551359                    for (iRow = 0; iRow < numberRows_; iRow++) {
    13561360                         double value = fabs(rhs[iRow]);
     
    13581362                         if (value > largest) {
    13591363                              largest = value;
     1364#if CLP_DEBUG > 0
    13601365                              iLargest = iRow;
     1366#endif
    13611367                         }
    13621368                    }
     
    14331439                              way = 1.0;
    14341440                         double largest = COIN_DBL_MAX;
     1441#ifdef CLP_DEBUG
    14351442                         int kPivot = -1;
     1443#endif
    14361444                         for (iIndex = 0; iIndex < number; iIndex++) {
    14371445                              int iRow = which2[iIndex];
     
    14411449                                   double distance = upper_[iPivot] - solution_[iPivot];
    14421450                                   if (distance < -largest * alpha) {
     1451#ifdef CLP_DEBUG
    14431452                                        kPivot = iPivot;
     1453#endif
    14441454                                        largest = CoinMax(0.0, -distance / alpha);
    14451455                                   }
     
    14511461                                   double distance = solution_[iPivot] - lower_[iPivot];
    14521462                                   if (distance < largest * alpha) {
     1463#ifdef CLP_DEBUG
    14531464                                        kPivot = iPivot;
     1465#endif
    14541466                                        largest = CoinMax(0.0, distance / alpha);
    14551467                                   }
     
    24952507     }
    24962508     dualOut_ = dj_[sequenceOut_];
    2497      double checkValue = 1.0e-2;
    2498      if (largestDualError_ > 1.0e-5)
    2499           checkValue = 1.0e-1;
    25002509     // if stable replace in basis
    25012510
     
    29422951                              break;
    29432952                         }
    2944                          int bestSequence = -1;
    29452953                         double theta = 1.0e30;
    29462954                         int iSequence;
     
    29532961                                   oldValue -= bound;
    29542962                                   if (oldValue + theta * alpha < 0.0) {
    2955                                         bestSequence = iSequence;
    29562963                                        theta = CoinMax(0.0, oldValue / (-alpha));
    29572964                                   }
     
    29612968                                   oldValue = bound - oldValue;
    29622969                                   if (oldValue - theta * alpha < 0.0) {
    2963                                         bestSequence = iSequence;
    29642970                                        theta = CoinMax(0.0, oldValue / alpha);
    29652971                                   }
     
    38353841                         double thisPenalty = 0.0;
    38363842                         infValue += infeasibility;
    3837                          double boundMultiplier = 1.0;
    3838                          if (sumOfActivities < 0.001)
    3839                               boundMultiplier = 0.1;
    3840                          else if (sumOfActivities > 100.0)
    3841                               boundMultiplier = 10.0;
    38423843                         int k;
    38433844                         assert (dualValue >= -1.0e-5);
     
    38683869                         double thisPenalty = 0.0;
    38693870                         infValue += infeasibility;
    3870                          double boundMultiplier = 1.0;
    3871                          if (sumOfActivities < 0.001)
    3872                               boundMultiplier = 0.1;
    3873                          else if (sumOfActivities > 100.0)
    3874                               boundMultiplier = 10.0;
    38753871                         int k;
    38763872                         dualValue = -dualValue;
  • trunk/Clp/src/ClpSimplexOther.cpp

    r1884 r1929  
    736736{
    737737     int status = 0;
    738      bool canOpen = false;
    739      if (!strcmp(fileName, "-") || !strcmp(fileName, "stdin")) {
    740           // stdin
    741           canOpen = true;
    742      } else {
     738     if (strcmp(fileName, "-") != 0 && strcmp(fileName, "stdin") != 0) {
    743739          FILE *fp = fopen(fileName, "r");
    744740          if (fp) {
    745741               // can open - lets go for it
    746742               fclose(fp);
    747                canOpen = true;
    748743          } else {
    749744               handler_->message(CLP_UNABLE_OPEN, messages_)
     
    23532348      int nBadLine = 0;
    23542349      int nBadName = 0;
    2355       bool goodLine=false;
    23562350      while (fgets(line, 200, fp)) {
    2357         goodLine=true;
    23582351        if (!strncmp(line, "ENDATA", 6)||
    23592352            !strncmp(line, "COLUMN",6))
    23602353          break;
    2361         goodLine=false;
    23622354        nLine++;
    23632355        iRow = -1;
     
    25302522        int nBadLine = 0;
    25312523        int nBadName = 0;
    2532         bool goodLine=false;
    25332524        while (fgets(line, 200, fp)) {
    2534           goodLine=true;
    25352525          if (!strncmp(line, "ENDATA", 6))
    25362526            break;
    2537           goodLine=false;
    25382527          nLine++;
    25392528          iColumn = -1;
     
    38983887                         problemStatus_ = -2; // factorize now
    38993888                    }
     3889#ifdef CLP_PARAMETRIC_DENSE_ARRAYS
    39003890                    int * lowerActive = paramData.lowerActive;
    39013891                    int * upperActive = paramData.upperActive;
     3892#endif
    39023893                    // update change vector
    39033894                    {
     
    83148305{
    83158306  char * put = where.putStuff;
    8316   int n = numberElements*(sizeof(int)+sizeof(double))+sizeInfo;
     8307  int n = numberElements*static_cast<int>(sizeof(int)+sizeof(double))+static_cast<int>(sizeInfo);
    83178308  if (n+(put-where.startStuff)>where.maxStuff) {
    83188309    where.maxStuff += CoinMax(where.maxStuff/2 + 10000, 2*n);
    83198310    char * temp = new char[where.maxStuff];
    8320     int k = put-where.startStuff;
     8311    long k = put-where.startStuff;
    83218312    memcpy(temp,where.startStuff,k);
    83228313    delete [] where.startStuff;
     
    85458536  int numberTotal=numberRows_+numberColumns_;
    85468537  CoinBigIndex lastElement = matrix_->getNumElements();
    8547   int maxInfoStuff = 5*lastElement*sizeof(double)+numberTotal*sizeof(clpPresolveInfo2);
     8538  int maxInfoStuff = 5*lastElement*static_cast<int>(sizeof(double))+numberTotal*static_cast<int>(sizeof(clpPresolveInfo2));
    85488539  clpPresolveInfo * infoA = new clpPresolveInfo[numberTotal];
    85498540  char * startStuff = new char [maxInfoStuff];
     
    86288619      thisInfo.lengthRow=n;
    86298620      //thisInfo.column=-1;
    8630       infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     8621      infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    86318622      infoA[nActions].type=4; //rowType[iRow];
    86328623      nActions++;
     
    86488639      thisInfo.column=iColumn;
    86498640      CoinBigIndex start=columnStart[iColumn];
    8650       infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     8641      infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    86518642      infoA[nActions].type=(columnType[iColumn]>0) ? columnType[iColumn] : 13;
    86528643      nActions++;
     
    87528743          thisInfo.lengthRow=n;
    87538744          //thisInfo.column=-1;
    8754           infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     8745          infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    87558746          infoA[nActions].type=1;
    87568747          nActions++;
     
    88218812        CoinBigIndex startCol=columnStart[iColumn2];
    88228813        thisInfo.lengthColumn2=nel;
    8823         infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     8814        infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    88248815        infoA[nActions].type=14;
    88258816        nActions++;
     
    90048995      thisInfo.lengthRow=n;
    90058996      //thisInfo.column=-1;
    9006       infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     8997      infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    90078998      infoA[nActions].type=1;
    90088999      nActions++;
     
    91889179        columnUpper[iColumn]=newUpper;
    91899180        thisInfo.column=iColumn;
    9190         infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     9181        infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    91919182        ClpCopyToMiniSave(stuff,reinterpret_cast<char *>(&thisInfo),sizeof(clpPresolveInfo2),
    91929183                   0,NULL,NULL);
     
    92109201          if (iRow!=jRowLower&&iRow!=jRowUpper) {
    92119202            // mark as redundant
    9212             infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     9203            infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    92139204            clpPresolveInfo1_4_8 thisInfo;
    92149205            thisInfo.oldRowLower=(rowLower_[iRow]>-1.0e30) ? rowLower_[iRow]-rowLower[iRow] : rowLower[iRow];
     
    93689359        CoinBigIndex start=columnStart[iColumn];
    93699360        thisInfo.lengthColumn=n;
    9370         infoA[nActions].infoOffset=stuff.putStuff-startStuff;
     9361        infoA[nActions].infoOffset=static_cast<int>(stuff.putStuff-startStuff);
    93719362        infoA[nActions].type=11;
    93729363        nActions++;
     
    94189409    eventHandler_->eventWithInfo(ClpEventHandler::moreMiniPresolve,&moreInfo);
    94199410    newModel->setObjectiveOffset(offset);
    9420     int nChar2 = nActions*sizeof(clpPresolveInfo)+(stuff.putStuff-startStuff);
     9411    int nChar2 = nActions*static_cast<int>(sizeof(clpPresolveInfo))+static_cast<int>(stuff.putStuff-startStuff);
    94219412    clpPresolveInfo * infoData = reinterpret_cast<clpPresolveInfo *>(new char[nChar2]);
    94229413    memcpy(infoData,infoA,nActions*sizeof(clpPresolveInfo));
  • trunk/Clp/src/ClpSolve.cpp

    r1924 r1929  
    13971397               double largest = 0.0;
    13981398               double smallest = 1.0e30;
    1399                double largestGap = 0.0;
    14001399               for (iRow = 0; iRow < numberRows; iRow++) {
    14011400                    double value1 = model2->rowLower_[iRow];
     
    14111410                    if (value2 > value1) {
    14121411                         numberNotE++;
    1413                          if (value2 > 1.0e31 || value1 < -1.0e31)
    1414                               largestGap = COIN_DBL_MAX;
    1415                          else
    1416                               largestGap = value2 - value1;
    14171412                    }
    14181413               }
  • trunk/Clp/src/Idiot.cpp

    r1910 r1929  
    423423     double firstInfeas;
    424424     int badIts = 0;
    425      int slackStart, slackEnd, ordStart, ordEnd;
     425     int slackStart, ordStart, ordEnd;
    426426     int checkIteration = 0;
    427427     int lambdaIteration = 0;
     
    617617     if (slackStart >= 0) {
    618618       COIN_DETAIL_PRINT(printf("This model has costed slacks\n"));
    619           slackEnd = slackStart + nrows;
    620619          if (slackStart) {
    621620               ordStart = 0;
     
    626625          }
    627626     } else {
    628           slackEnd = slackStart;
    629627          ordStart = 0;
    630628          ordEnd = ncols;
Note: See TracChangeset for help on using the changeset viewer.