Changeset 1726 for trunk


Ignore:
Timestamp:
May 2, 2011 4:58:39 AM (9 years ago)
Author:
stefan
Message:

fix compiler warnings, including one that pointed to a bug

Location:
trunk/Clp/src
Files:
10 edited

Legend:

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

    r1724 r1726  
    44// This code is licensed under the terms of the Eclipse Public License (EPL).
    55
    6 #if defined(_MSC_VER)
    7 // Turn off compiler warning about long names
    8 #  pragma warning(disable:4786)
    9 #endif
    10 
     6#include "CoinPragma.hpp"
    117#include "CbcOrClpParam.hpp"
    128
     
    537533#endif
    538534     case CLP_PARAM_DBL_ZEROTOLERANCE:
    539           model->setSmallElementValue(value);
     535          value = model->getSmallElementValue();
    540536          break;
    541537     case CLP_PARAM_DBL_DUALBOUND:
     
    10201016extern int CbcOrClpRead_mode;
    10211017int CbcOrClpEnvironmentIndex = -1;
    1022 static int fillEnv()
     1018static size_t fillEnv()
    10231019{
    10241020#if defined(_MSC_VER) || defined(__MSVCRT__)
     
    10271023     // Don't think it will work on Windows
    10281024     char * environ = getenv("CBC_CLP_ENVIRONMENT");
    1029      int length = 0;
     1025     size_t length = 0;
    10301026     if (environ) {
    10311027          length = strlen(environ);
    1032           if (CbcOrClpEnvironmentIndex < length) {
     1028          if (CbcOrClpEnvironmentIndex < static_cast<int>(length)) {
    10331029               // find next non blank
    10341030               char * whereEnv = environ + CbcOrClpEnvironmentIndex;
     
    10471043                    whereEnv++;
    10481044               }
    1049                CbcOrClpEnvironmentIndex = whereEnv - environ;
     1045               CbcOrClpEnvironmentIndex = static_cast<int>(whereEnv - environ);
    10501046               *put = '\0';
    10511047               length = strlen(line);
     
    12361232          afterEquals = "";
    12371233     }
    1238      int value = 0;
     1234     long int value = 0;
    12391235     //std::cout<<field<<std::endl;
    12401236     if (field != "EOL") {
     
    12521248          *valid = 2;
    12531249     }
    1254      return value;
     1250     return static_cast<int>(value);
    12551251}
    12561252double
     
    34053401               if (numberRows == numberRowsFile && numberColumns == numberColumnsFile) {
    34063402                    nRead = fread(primalRowSolution, sizeof(double), numberRows, fp);
    3407                     if (nRead != numberRows)
     3403                    if (nRead != static_cast<size_t>(numberRows))
    34083404                         throw("Error in fread");
    34093405                    nRead = fread(dualRowSolution, sizeof(double), numberRows, fp);
    3410                     if (nRead != numberRows)
     3406                    if (nRead != static_cast<size_t>(numberRows))
    34113407                         throw("Error in fread");
    34123408                    nRead = fread(primalColumnSolution, sizeof(double), numberColumns, fp);
    3413                     if (nRead != numberColumns)
     3409                    if (nRead != static_cast<size_t>(numberColumns))
    34143410                         throw("Error in fread");
    34153411                    nRead = fread(dualColumnSolution, sizeof(double), numberColumns, fp);
    3416                     if (nRead != numberColumns)
     3412                    if (nRead != static_cast<size_t>(numberColumns))
    34173413                         throw("Error in fread");
    34183414               } else {
     
    34203416                    double * temp = new double [CoinMax(numberRowsFile, numberColumnsFile)];
    34213417                    nRead = fread(temp, sizeof(double), numberRowsFile, fp);
    3422                     if (nRead != numberRowsFile)
     3418                    if (nRead != static_cast<size_t>(numberRowsFile))
    34233419                         throw("Error in fread");
    34243420                    CoinMemcpyN(temp, numberRows, primalRowSolution);
    34253421                    nRead = fread(temp, sizeof(double), numberRowsFile, fp);
    3426                     if (nRead != numberRowsFile)
     3422                    if (nRead != static_cast<size_t>(numberRowsFile))
    34273423                         throw("Error in fread");
    34283424                    CoinMemcpyN(temp, numberRows, dualRowSolution);
    34293425                    nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
    3430                     if (nRead != numberColumnsFile)
     3426                    if (nRead != static_cast<size_t>(numberColumnsFile))
    34313427                         throw("Error in fread");
    34323428                    CoinMemcpyN(temp, numberColumns, primalColumnSolution);
    34333429                    nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
    3434                     if (nRead != numberColumnsFile)
     3430                    if (nRead != static_cast<size_t>(numberColumnsFile))
    34353431                         throw("Error in fread");
    34363432                    CoinMemcpyN(temp, numberColumns, dualColumnSolution);
     
    35073503          double * primalRowSolution = lpSolver->primalRowSolution();
    35083504          nWrite = fwrite(primalRowSolution, sizeof(double), numberRows, fp);
    3509           if (nWrite != numberRows)
     3505          if (nWrite != static_cast<size_t>(numberRows))
    35103506               throw("Error in fwrite");
    35113507          nWrite = fwrite(dualRowSolution, sizeof(double), numberRows, fp);
    3512           if (nWrite != numberRows)
     3508          if (nWrite != static_cast<size_t>(numberRows))
    35133509               throw("Error in fwrite");
    35143510          double * dualColumnSolution = lpSolver->dualColumnSolution();
    35153511          double * primalColumnSolution = lpSolver->primalColumnSolution();
    35163512          nWrite = fwrite(primalColumnSolution, sizeof(double), numberColumns, fp);
    3517           if (nWrite != numberColumns)
     3513          if (nWrite != static_cast<size_t>(numberColumns))
    35183514               throw("Error in fwrite");
    35193515          nWrite = fwrite(dualColumnSolution, sizeof(double), numberColumns, fp);
    3520           if (nWrite != numberColumns)
     3516          if (nWrite != static_cast<size_t>(numberColumns))
    35213517               throw("Error in fwrite");
    35223518          fclose(fp);
  • trunk/Clp/src/ClpCholeskyDense.cpp

    r1723 r1726  
    806806     double dropValue = thisStruct->doubleParameters_[0];
    807807     int firstPositive = thisStruct->integerParameters_[0];
    808      int rowOffset = diagonal - thisStruct->diagonal_;
     808     int rowOffset = static_cast<int>(diagonal - thisStruct->diagonal_);
    809809     int i, j, k;
    810810     CoinWorkDouble t00, temp1;
  • trunk/Clp/src/ClpDynamicMatrix.cpp

    r1678 r1726  
    9494     lowerSet_ = ClpCopyOfArray(rhs.lowerSet_, numberSets_);
    9595     upperSet_ = ClpCopyOfArray(rhs.upperSet_, numberSets_);
    96      status_ = ClpCopyOfArray(rhs.status_, 2*numberSets_+4*sizeof(int));
     96     status_ = ClpCopyOfArray(rhs.status_, static_cast<int>(2*numberSets_+4*sizeof(int)));
    9797     model_ = rhs.model_;
    9898     sumDualInfeasibilities_ = rhs. sumDualInfeasibilities_;
     
    263263     keyVariable_ = new int[numberSets_];
    264264     if (status) {
    265           status_ = ClpCopyOfArray(status, 2*numberSets_+4*sizeof(int));
     265          status_ = ClpCopyOfArray(status, static_cast<int>(2*numberSets_+4*sizeof(int)));
    266266          assert (dynamicStatus);
    267267          dynamicStatus_ = ClpCopyOfArray(dynamicStatus, 2*numberGubColumns_);
     
    360360          lowerSet_ = ClpCopyOfArray(rhs.lowerSet_, numberSets_);
    361361          upperSet_ = ClpCopyOfArray(rhs.upperSet_, numberSets_);
    362           status_ = ClpCopyOfArray(rhs.status_, 2*numberSets_+4*sizeof(int));
     362          status_ = ClpCopyOfArray(rhs.status_, static_cast<int>(2*numberSets_+4*sizeof(int)));
    363363          model_ = rhs.model_;
    364364          sumDualInfeasibilities_ = rhs. sumDualInfeasibilities_;
  • trunk/Clp/src/ClpMain.cpp

    r1724 r1726  
    286286               int numberQuery = 0;
    287287               if (field != "?" && field != "???") {
    288                     int length = field.length();
    289                     int i;
     288                    size_t length = field.length();
     289                    size_t i;
    290290                    for (i = length - 1; i > 0; i--) {
    291291                         if (field[i] == '?')
     
    949949                                   {
    950950                                        const char * c_name = field.c_str();
    951                                         int length = strlen(c_name);
     951                                        size_t length = strlen(c_name);
    952952                                        if (length > 3 && !strncmp(c_name + length - 3, ".lp", 3))
    953953                                             gmpl = -1; // .lp
     
    966966                                   if (absolutePath) {
    967967                                        fileName = field;
    968                                         int length = field.size();
    969                                         int percent = field.find('%');
     968                                        size_t length = field.size();
     969                                        size_t percent = field.find('%');
    970970                                        if (percent < length && percent > 0) {
    971971                                             gmpl = 1;
     
    989989                                        fileName = directory + field;
    990990                                        // See if gmpl (model & data) - or even lp file
    991                                         int length = field.size();
    992                                         int percent = field.find('%');
     991                                        size_t length = field.size();
     992                                        size_t percent = field.find('%');
    993993                                        if (percent < length && percent > 0) {
    994994                                             gmpl = 1;
     
    15521552                              std::string name = CoinReadGetString(argc, argv);
    15531553                              if (name != "EOL") {
    1554                                    int length = name.length();
    1555                                    if (name[length-1] == dirsep) {
     1554                                   size_t length = name.length();
     1555                                   if (length > 0 && name[length-1] == dirsep) {
    15561556                                        directory = name;
    15571557                                   } else {
     
    15671567                              std::string name = CoinReadGetString(argc, argv);
    15681568                              if (name != "EOL") {
    1569                                    int length = name.length();
    1570                                    if (name[length-1] == dirsep) {
     1569                                   size_t length = name.length();
     1570                                   if (length > 0 && name[length-1] == dirsep) {
    15711571                                        dirSample = name;
    15721572                                   } else {
     
    15821582                              std::string name = CoinReadGetString(argc, argv);
    15831583                              if (name != "EOL") {
    1584                                    int length = name.length();
    1585                                    if (name[length-1] == dirsep) {
     1584                                   size_t length = name.length();
     1585                                   if (length > 0 && name[length-1] == dirsep) {
    15861586                                        dirNetlib = name;
    15871587                                   } else {
     
    15971597                              std::string name = CoinReadGetString(argc, argv);
    15981598                              if (name != "EOL") {
    1599                                    int length = name.length();
    1600                                    if (name[length-1] == dirsep) {
     1599                                   size_t length = name.length();
     1600                                   if (length > 0 && name[length-1] == dirsep) {
    16011601                                        dirMiplib = name;
    16021602                                   } else {
     
    19451945                                             const char * pMask2 = printMask.c_str();
    19461946                                             char pMask[100];
    1947                                              int iChar;
    1948                                              int lengthMask = strlen(pMask2);
     1947                                             size_t lengthMask = strlen(pMask2);
    19491948                                             assert (lengthMask < 100);
    19501949                                             if (*pMask2 == '"') {
     
    19671966                                                  strcpy(pMask, pMask2);
    19681967                                             }
    1969                                              if (lengthMask > lengthName) {
     1968                                             if (lengthMask > static_cast<size_t>(lengthName)) {
    19701969                                                  printf("mask %s too long - skipping\n", pMask);
    19711970                                                  break;
    19721971                                             }
    19731972                                             maxMasks = 1;
    1974                                              for (iChar = 0; iChar < lengthMask; iChar++) {
     1973                                             for (size_t iChar = 0; iChar < lengthMask; iChar++) {
    19751974                                                  if (pMask[iChar] == '*') {
    19761975                                                       nAst++;
     
    19951994                                                       char * ast = strchr(oldMask, '*');
    19961995                                                       assert (ast);
    1997                                                        int length = strlen(oldMask) - 1;
    1998                                                        int nBefore = ast - oldMask;
    1999                                                        int nAfter = length - nBefore;
     1996                                                       size_t length = strlen(oldMask) - 1;
     1997                                                       size_t nBefore = ast - oldMask;
     1998                                                       size_t nAfter = length - nBefore;
    20001999                                                       // and add null
    20012000                                                       nAfter++;
    2002                                                        for (int i = 0; i <= lengthName - length; i++) {
     2001                                                       for (size_t i = 0; i <= lengthName - length; i++) {
    20032002                                                            char * maskOut = newMasks[nEntries];
    2004                                                             CoinMemcpyN(oldMask, nBefore, maskOut);
    2005                                                             for (int k = 0; k < i; k++)
     2003                                                            CoinMemcpyN(oldMask, static_cast<int>(nBefore), maskOut);
     2004                                                            for (size_t k = 0; k < i; k++)
    20062005                                                                 maskOut[k+nBefore] = '?';
    2007                                                             CoinMemcpyN(ast + 1, nAfter, maskOut + nBefore + i);
     2006                                                            CoinMemcpyN(ast + 1, static_cast<int>(nAfter), maskOut + nBefore + i);
    20082007                                                            nEntries++;
    20092008                                                            assert (nEntries <= maxMasks);
     
    20182017                                             for (i = 0; i < nEntries; i++) {
    20192018                                                  char * maskThis = masks[i];
    2020                                                   int length = strlen(maskThis);
    2021                                                   while (maskThis[length-1] == ' ')
     2019                                                  size_t length = strlen(maskThis);
     2020                                                  while (length > 0 && maskThis[length-1] == ' ')
    20222021                                                       length--;
    20232022                                                  maskThis[length] = '\0';
    2024                                                   sort[i] = length;
     2023                                                  sort[i] = static_cast<int>(length);
    20252024                                             }
    20262025                                             CoinSort_2(sort, sort + nEntries, masks);
     
    21942193                                                       if (lengthName) {
    21952194                                                            const char * name = rowNames[iRow].c_str();
    2196                                                             int n = strlen(name);
    2197                                                             int i;
     2195                                                            size_t n = strlen(name);
     2196                                                            size_t i;
    21982197                                                            for (i = 0; i < n; i++)
    21992198                                                                 fprintf(fp, "%c", name[i]);
    2200                                                             for (; i < lengthPrint; i++)
     2199                                                            for (; i < static_cast<size_t>(lengthPrint); i++)
    22012200                                                                 fprintf(fp, " ");
    22022201                                                       }
     
    22322231                                                  if (lengthName) {
    22332232                                                       const char * name = columnNames[iColumn].c_str();
    2234                                                        int n = strlen(name);
    2235                                                        int i;
     2233                                                       size_t n = strlen(name);
     2234                                                       size_t i;
    22362235                                                       for (i = 0; i < n; i++)
    22372236                                                            fprintf(fp, "%c", name[i]);
    2238                                                        for (; i < lengthPrint; i++)
     2237                                                       for (; i < static_cast<size_t>(lengthPrint); i++)
    22392238                                                            fprintf(fp, " ");
    22402239                                                  }
     
    32903289     // back to char as I am old fashioned
    32913290     const char * checkC = check.c_str();
    3292      int length = strlen(checkC);
     3291     size_t length = strlen(checkC);
    32933292     while (checkC[length-1] == ' ')
    32943293          length--;
    32953294     for (int i = starts[length]; i < starts[length+1]; i++) {
    32963295          char * thisMask = masks[i];
    3297           int k;
     3296          size_t k;
    32983297          for ( k = 0; k < length; k++) {
    32993298               if (thisMask[k] != '?' && thisMask[k] != checkC[k])
  • trunk/Clp/src/ClpModel.cpp

    r1723 r1726  
    32903290     }
    32913291#endif
    3292      int size = rowNames_.size();
     3292     int size = static_cast<int>(rowNames_.size());
    32933293     if (size > iRow) {
    32943294          return rowNames_[iRow];
     
    33103310#endif
    33113311     unsigned int maxLength = lengthNames_;
    3312      int size = rowNames_.size();
     3312     size_t size = static_cast<int>(rowNames_.size());
    33133313     if (size <= iRow)
    33143314          rowNames_.resize(iRow + 1);
     
    33273327     }
    33283328#endif
    3329      int size = columnNames_.size();
     3329     int size = static_cast<int>(columnNames_.size());
    33303330     if (size > iColumn) {
    33313331          return columnNames_[iColumn];
     
    33473347#endif
    33483348     unsigned int maxLength = lengthNames_;
    3349      int size = columnNames_.size();
     3349     int size = static_cast<int>(columnNames_.size());
    33503350     if (size <= iColumn)
    33513351          columnNames_.resize(iColumn + 1);
     
    33603360{
    33613361     unsigned int maxLength = lengthNames_;
    3362      int size = rowNames_.size();
     3362     int size = static_cast<int>(rowNames_.size());
    33633363     if (size != numberRows_)
    33643364          rowNames_.resize(numberRows_);
     
    33763376{
    33773377     unsigned int maxLength = lengthNames_;
    3378      int size = columnNames_.size();
     3378     int size = static_cast<int>(columnNames_.size());
    33793379     if (size != numberColumns_)
    33803380          columnNames_.resize(numberColumns_);
     
    33923392{
    33933393     unsigned int maxLength = lengthNames_;
    3394      int size = rowNames_.size();
     3394     int size = static_cast<int>(rowNames_.size());
    33953395     if (size != numberRows_)
    33963396          rowNames_.resize(numberRows_);
     
    34153415{
    34163416     unsigned int maxLength = lengthNames_;
    3417      int size = columnNames_.size();
     3417     int size = static_cast<int>(columnNames_.size());
    34183418     if (size != numberColumns_)
    34193419          columnNames_.resize(numberColumns_);
     
    36503650     if (lengthNames()) {
    36513651          rowNames = new char * [numberRows_+1];
    3652           int numberNames = rowNames_.size();
     3652          int numberNames = static_cast<int>(rowNames_.size());
    36533653          numberNames = CoinMin(numberRows_, numberNames);
    36543654          int iRow;
     
    36903690     if (lengthNames()) {
    36913691          columnNames = new char * [numberColumns_];
    3692           int numberNames = columnNames_.size();
     3692          int numberNames = static_cast<int>(columnNames_.size());
    36933693          numberNames = CoinMin(numberColumns_, numberNames);
    36943694          int iColumn;
     
    38873887          char temp[30];
    38883888          strcpy(temp, rowName(i).c_str());
    3889           int length = strlen(temp);
    3890           for (int j = 0; j < length; j++) {
     3889          size_t length = strlen(temp);
     3890          for (size_t j = 0; j < length; j++) {
    38913891               if (temp[j] == '-')
    38923892                    temp[j] = '_';
     
    38973897          char temp[30];
    38983898          strcpy(temp, columnName(i).c_str());
    3899           int length = strlen(temp);
    3900           for (int j = 0; j < length; j++) {
     3899          size_t length = strlen(temp);
     3900          for (size_t j = 0; j < length; j++) {
    39013901               if (temp[j] == '-')
    39023902                    temp[j] = '_';
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1723 r1726  
    40714071#ifndef COIN_BIG_INDEX
    40724072                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
     4073#elif COIN_BIG_INDEX==0
     4074                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
    40734075#elif COIN_BIG_INDEX==1
    40744076                         printf("Out of range %d %ld %d %g\n", iColumn, j, row[j], elementByColumn[j]);
     
    41194121                    if (iRow < 0 || iRow >= numberRows) {
    41204122#ifndef COIN_BIG_INDEX
     4123                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
     4124#elif COIN_BIG_INDEX==0
    41214125                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
    41224126#elif COIN_BIG_INDEX==1
  • trunk/Clp/src/ClpPredictorCorrector.cpp

    r1723 r1726  
    818818          CoinWorkDouble nextCenterGap = 0.0;
    819819          int numberGoodTries = 0;
     820#ifdef COIN_DETAIL
    820821          CoinWorkDouble originalDualStep = actualDualStep_;
    821822          CoinWorkDouble originalPrimalStep = actualPrimalStep_;
     823#endif
    822824          if (actualDualStep_ > 0.9 && actualPrimalStep_ > 0.9)
    823825               goodMove = false; // don't bother
  • trunk/Clp/src/ClpSimplex.cpp

    r1723 r1726  
    62166216int outDoubleArray(double * array, int length, FILE * fp)
    62176217{
    6218      int numberWritten;
     6218     size_t numberWritten;
    62196219     if (array && length) {
    62206220          numberWritten = fwrite(&length, sizeof(int), 1, fp);
     
    62226222               return 1;
    62236223          numberWritten = fwrite(array, sizeof(double), length, fp);
    6224           if (numberWritten != length)
     6224          if (numberWritten != static_cast<size_t>(length))
    62256225               return 1;
    62266226     } else {
     
    62396239     if (fp) {
    62406240          Clp_scalars scalars;
    6241           CoinBigIndex numberWritten;
     6241          size_t numberWritten;
    62426242          // Fill in scalars
    62436243          scalars.optimizationDirection = optimizationDirection_;
     
    62736273          if (numberWritten != 1)
    62746274               return 1;
    6275           CoinBigIndex length;
     6275          size_t length;
    62766276#ifndef CLP_NO_STD
    62776277          int i;
     
    63516351               }
    63526352               numberWritten = fwrite(array, lengthNames_ + 1, numberRows_, fp);
    6353                if (numberWritten != numberRows_)
     6353               if (numberWritten != static_cast<size_t>(numberRows_))
    63546354                    return 1;
    63556355               put = array;
     
    63616361               }
    63626362               numberWritten = fwrite(array, lengthNames_ + 1, numberColumns_, fp);
    6363                if (numberWritten != numberColumns_)
     6363               if (numberWritten != static_cast<size_t>(numberColumns_))
    63646364                    return 1;
    63656365               delete [] array;
     
    63716371               numberWritten = fwrite(&marker, sizeof(int), 1, fp);
    63726372               numberWritten = fwrite(integerType_, 1, numberColumns_, fp);
    6373                if (numberWritten != numberColumns_)
     6373               if (numberWritten != static_cast<size_t>(numberColumns_))
    63746374                    return 1;
    63756375          } else {
     
    63976397          numberWritten = fwrite(matrix_->getVectorStarts(),
    63986398                                 sizeof(int), numberColumns_ + 1, fp);
    6399           if (numberWritten != numberColumns_ + 1)
     6399          if (numberWritten != static_cast<size_t>(numberColumns_) + 1)
    64006400               return 1;
    64016401          numberWritten = fwrite(matrix_->getVectorLengths(),
    64026402                                 sizeof(int), numberColumns_, fp);
    6403           if (numberWritten != numberColumns_)
     6403          if (numberWritten != static_cast<size_t>(numberColumns_))
    64046404               return 1;
    64056405          // finished
     
    64136413int inDoubleArray(double * &array, int length, FILE * fp)
    64146414{
    6415      int numberRead;
     6415     size_t numberRead;
    64166416     int length2;
    64176417     numberRead = fread(&length2, sizeof(int), 1, fp);
     
    64246424          array = new double[length];
    64256425          numberRead = fread(array, sizeof(double), length, fp);
    6426           if (numberRead != length)
     6426          if (numberRead != static_cast<size_t>(length))
    64276427               return 1;
    64286428     }
     
    64526452          factorization_->sparseThreshold(1);
    64536453          Clp_scalars scalars;
    6454           CoinBigIndex numberRead;
     6454          size_t numberRead;
    64556455
    64566456          // get scalars
     
    65516551               status_ = new char unsigned[length];
    65526552               numberRead = fread(status_, sizeof(char), length, fp);
    6553                if (numberRead != length)
     6553               if (numberRead != static_cast<size_t>(length))
    65546554                    return 1;
    65556555          }
     
    65606560               char * get = array;
    65616561               numberRead = fread(array, lengthNames_ + 1, numberRows_, fp);
    6562                if (numberRead != numberRows_)
     6562               if (numberRead != static_cast<size_t>(numberRows_))
    65636563                    return 1;
    65646564               rowNames_ = std::vector<std::string> ();
     
    65706570               get = array;
    65716571               numberRead = fread(array, lengthNames_ + 1, numberColumns_, fp);
    6572                if (numberRead != numberColumns_)
     6572               if (numberRead != static_cast<size_t>(numberColumns_))
    65736573                    return 1;
    65746574               columnNames_ = std::vector<std::string> ();
     
    65926592               integerType_ = new char [numberColumns_];
    65936593               numberRead = fread(integerType_, 1, numberColumns_, fp);
    6594                if (numberRead != numberColumns_)
     6594               if (numberRead != static_cast<size_t>(numberColumns_))
    65956595                    return 1;
    65966596          } else {
     
    66466646          int * lengths = new int[numberColumns_];
    66476647          numberRead = fread(elements, sizeof(double), length, fp);
    6648           if (numberRead != length)
     6648          if (numberRead != static_cast<size_t>(length))
    66496649               return 1;
    66506650          numberRead = fread(indices, sizeof(int), length, fp);
    6651           if (numberRead != length)
     6651          if (numberRead != static_cast<size_t>(length))
    66526652               return 1;
    66536653          numberRead = fread(starts, sizeof(int), numberColumns_ + 1, fp);
    6654           if (numberRead != numberColumns_ + 1)
     6654          if (numberRead != static_cast<size_t>(numberColumns_) + 1)
    66556655               return 1;
    66566656          numberRead = fread(lengths, sizeof(int), numberColumns_, fp);
    6657           if (numberRead != numberColumns_)
     6657          if (numberRead != static_cast<size_t>(numberColumns_))
    66586658               return 1;
    66596659          // assign matrix
  • trunk/Clp/src/MyMessageHandler.cpp

    r1665 r1726  
    55
    66#if defined(_MSC_VER)
    7 #pragma warning(disable:4786)
     7// move into CoinPragma.hpp ?
    88#pragma warning(disable:4503)
    99#endif
     
    1111#include <cstdio>
    1212
     13#include "CoinPragma.hpp"
    1314#include "ClpSimplex.hpp"
    1415#include "ClpNonLinearCost.hpp"
     
    128129
    129130                    // Want maximum of 10 solutions, so if more then 10 get rid of oldest
    130                     int numExtremePointsSaved = feasibleExtremePoints_.size();
     131                    size_t numExtremePointsSaved = feasibleExtremePoints_.size();
    131132                    if ( numExtremePointsSaved >= 10 ) {
    132133                         feasibleExtremePoints_.pop_back();
    133                          assert( feasibleExtremePoints_.size() ==
    134                                  static_cast<unsigned int> (numExtremePointsSaved) - 1 );
     134                         assert( feasibleExtremePoints_.size() == numExtremePointsSaved - 1 );
    135135                    };
    136136
  • trunk/Clp/src/unitTest.cpp

    r1722 r1726  
    13561356               // Write saved solutions
    13571357               int nc = model.getNumCols();
    1358                int s;
     1358               size_t s;
    13591359               std::deque<StdVectorDouble> fep = messageHandler.getFeasibleExtremePoints();
    1360                int numSavedSolutions = fep.size();
     1360               size_t numSavedSolutions = fep.size();
    13611361               for ( s = 0; s < numSavedSolutions; ++s ) {
    13621362                    const StdVectorDouble & solnVec = fep[s];
Note: See TracChangeset for help on using the changeset viewer.