Changeset 1404 for stable


Ignore:
Timestamp:
Jul 28, 2009 8:25:35 AM (10 years ago)
Author:
tkr
Message:

Merging r1375:1393 from stable/BSP to stable/1.10

Location:
stable/1.10/Clp
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • stable/1.10/Clp

  • stable/1.10/Clp/src/CbcOrClpParam.cpp

    r1344 r1404  
    232232{
    233233  std::string::size_type  shriekPos = name_.find('!');
    234   lengthName_ = name_.length();
     234  lengthName_ = (unsigned int)name_.length();
    235235  if ( shriekPos==std::string::npos ) {
    236236    //does not contain '!'
    237237    lengthMatch_= lengthName_;
    238238  } else {
    239     lengthMatch_=shriekPos;
     239    lengthMatch_=(unsigned int)shriekPos;
    240240    name_ = name_.substr(0,shriekPos)+name_.substr(shriekPos+1);
    241241    lengthName_--;
     
    285285CbcOrClpParam::parameterOption ( std::string check ) const
    286286{
    287   int numberItems = definedKeyWords_.size();
     287  size_t numberItems = definedKeyWords_.size();
    288288  if (!numberItems) {
    289289    return -1;
    290290  } else {
    291     int whichItem=0;
     291    size_t whichItem=0;
    292292    unsigned int it;
    293293    for (it=0;it<definedKeyWords_.size();it++) {
    294294      std::string thisOne = definedKeyWords_[it];
    295       std::string::size_type  shriekPos = thisOne.find('!');
    296       unsigned int length1 = thisOne.length();
    297       unsigned int length2 = length1;
     295      std::string::size_type shriekPos = thisOne.find('!');
     296      std::string::size_type length1 = thisOne.length();
     297      std::string::size_type length2 = length1;
    298298      if ( shriekPos!=std::string::npos ) {
    299299        //contains '!'
     
    304304      }
    305305      if (check.length()<=length1&&length2<=check.length()) {
    306         unsigned int i;
     306        std::string::size_type i;
    307307        for (i=0;i<check.length();i++) {
    308308          if (tolower(thisOne[i])!=tolower(check[i]))
     
    319319    }
    320320    if (whichItem<numberItems)
    321       return whichItem;
     321      return (int)whichItem;
    322322    else
    323323      return -1;
     
    364364void CoinReadPrintit(const char * input)
    365365{
    366   int length =strlen(input);
     366  size_t length =strlen(input);
    367367  char temp[101];
    368   int i;
     368  size_t i;
    369369  int n=0;
    370370  for (i=0;i<length;i++) {
     
    11561156    afterEquals = "";
    11571157  }
    1158   int value=0;
     1158  size_t value=0;
    11591159  //std::cout<<field<<std::endl;
    11601160  if (field!="EOL") {
     
    11721172    *valid=2;
    11731173  }
    1174   return value;
     1174  return (int)value;
    11751175}
    11761176double
  • stable/1.10/Clp/src/ClpCholeskyDense.cpp

    r1321 r1404  
    780780  double dropValue = doubleParameters_[10];
    781781  int firstPositive=integerParameters_[34];
    782   int rowOffset=diagonal-diagonal_;
     782  size_t rowOffset=diagonal-diagonal_;
    783783  int numberDropped=0;
    784784  int i, j, k;
     
    795795    bool dropColumn=false;
    796796    longDouble useT00=t00;
    797     if (j+rowOffset<firstPositive) {
     797    if ((int)(j+rowOffset)<firstPositive) {
    798798      // must be negative
    799799      if (t00<=-dropValue) {
  • stable/1.10/Clp/src/ClpMain.cpp

    r1344 r1404  
    239239      int numberQuery=0;
    240240      if (field!="?"&&field!="???") {
    241         int length = field.length();
    242         int i;
     241        size_t length = field.length();
     242        long i;
    243243        for (i=length-1;i>0;i--) {
    244244          if (field[i]=='?')
     
    880880                {
    881881                  const char * c_name = field.c_str();
    882                   int length = strlen(c_name);
     882                  size_t length = strlen(c_name);
    883883                  if (length>3&&!strncmp(c_name+length-3,".lp",3))
    884884                    gmpl=-1; // .lp
     
    909909                  fileName = directory+field;
    910910                  // See if gmpl (model & data) - or even lp file
    911                   int length = field.size();
    912                   int percent = field.find('%');
     911                  size_t length = field.size();
     912                  size_t percent = field.find('%');
    913913                  if (percent<length&&percent>0) {
    914914                    gmpl=1;
    915915                    fileName = directory+field.substr(0,percent);
    916916                    gmplData = directory+field.substr(percent+1);
    917                     if (percent<length-1)
     917                    if (percent+1<length)
    918918                      gmpl=2; // two files
    919919                    printf("GMPL model file %s and data file %s\n",
     
    14321432              std::string name = CoinReadGetString(argc,argv);
    14331433              if (name!="EOL") {
    1434                 int length=name.length();
     1434                size_t length=name.length();
    14351435                if (name[length-1]==dirsep) {
    14361436                  directory = name;
     
    14481448              std::string name = CoinReadGetString(argc,argv);
    14491449              if (name!="EOL") {
    1450                 int length=name.length();
     1450                size_t length=name.length();
    14511451                if (name[length-1]==dirsep) {
    14521452                  dirSample = name;
     
    14641464              std::string name = CoinReadGetString(argc,argv);
    14651465              if (name!="EOL") {
    1466                 int length=name.length();
     1466                size_t length=name.length();
    14671467                if (name[length-1]==dirsep) {
    14681468                  dirNetlib = name;
     
    14801480              std::string name = CoinReadGetString(argc,argv);
    14811481              if (name!="EOL") {
    1482                 int length=name.length();
     1482                size_t length=name.length();
    14831483                if (name[length-1]==dirsep) {
    14841484                  dirMiplib = name;
     
    16891689                int iRow;
    16901690                int numberRows=models[iModel].numberRows();
    1691                 int lengthName = models[iModel].lengthNames(); // 0 if no names
     1691                size_t lengthName = models[iModel].lengthNames(); // 0 if no names
    16921692                // in general I don't want to pass around massive
    16931693                // amounts of data but seems simpler here
     
    17041704                double primalTolerance = models[iModel].primalTolerance();
    17051705                char format[6];
    1706                 sprintf(format,"%%-%ds",CoinMax(lengthName,8));
     1706                sprintf(format,"%%-%ds",(int)CoinMax(lengthName,(size_t)8));
    17071707                bool doMask = (printMask!=""&&lengthName);
    17081708                int * maskStarts=NULL;
    1709                 int maxMasks=0;
     1709                size_t maxMasks=0;
    17101710                char ** masks =NULL;
    17111711                if (doMask) {
     
    17131713                  const char * pMask2 = printMask.c_str();
    17141714                  char pMask[100];
    1715                   int iChar;
    1716                   int lengthMask = strlen(pMask2);
     1715                  size_t iChar;
     1716                  size_t lengthMask = strlen(pMask2);
    17171717                  assert (lengthMask<100);
    17181718                  if (*pMask2=='"') {
     
    17461746                    }
    17471747                  }
    1748                   int nEntries = 1;
     1748                  size_t nEntries = 1;
    17491749                  maskStarts = new int[lengthName+2];
    17501750                  masks = new char * [maxMasks];
    17511751                  char ** newMasks = new char * [maxMasks];
    1752                   int i;
     1752                  size_t i;
    17531753                  for (i=0;i<maxMasks;i++) {
    17541754                    masks[i] = new char[lengthName+1];
     
    17571757                  strcpy(masks[0],pMask);
    17581758                  for (int iAst=0;iAst<nAst;iAst++) {
    1759                     int nOldEntries = nEntries;
     1759                    size_t nOldEntries = nEntries;
    17601760                    nEntries=0;
    1761                     for (int iEntry = 0;iEntry<nOldEntries;iEntry++) {
     1761                    for (size_t iEntry = 0;iEntry<nOldEntries;iEntry++) {
    17621762                      char * oldMask = masks[iEntry];
    17631763                      char * ast = strchr(oldMask,'*');
    17641764                      assert (ast);
    1765                       int length = strlen(oldMask)-1;
    1766                       int nBefore = ast-oldMask;
    1767                       int nAfter = length-nBefore;
     1765                      size_t length = strlen(oldMask)-1;
     1766                      size_t nBefore = ast-oldMask;
     1767                      size_t nAfter = length-nBefore;
    17681768                      // and add null
    17691769                      nAfter++;
    1770                       for (int i=0;i<=lengthName-length;i++) {
     1770                      for (size_t i=0;i<=lengthName-length;i++) {
    17711771                        char * maskOut = newMasks[nEntries];
    17721772   CoinMemcpyN(oldMask,nBefore,maskOut);
    1773                         for (int k=0;k<i;k++)
     1773                        for (size_t k=0;k<i;k++)
    17741774                          maskOut[k+nBefore]='?';
    17751775   CoinMemcpyN(ast+1,nAfter,maskOut+nBefore+i);
     
    17831783                  }
    17841784                  // Now extend and sort
    1785                   int * sort = new int[nEntries];
     1785                  size_t* sort = new size_t[nEntries];
    17861786                  for (i=0;i<nEntries;i++) {
    17871787                    char * maskThis = masks[i];
    1788                     int length = strlen(maskThis);
     1788                    size_t length = strlen(maskThis);
    17891789                    while (maskThis[length-1]==' ')
    17901790                      length--;
     
    17931793                  }
    17941794                  CoinSort_2(sort,sort+nEntries,masks);
    1795                   int lastLength=-1;
     1795                  long lastLength=-1;
    17961796                  for (i=0;i<nEntries;i++) {
    1797                     int length = sort[i];
    1798                     while (length>lastLength)
    1799                       maskStarts[++lastLength] = i;
    1800                   }
    1801                   maskStarts[++lastLength]=nEntries;
     1797                    size_t length = sort[i];
     1798                    while ((long)length>lastLength)
     1799                      maskStarts[++lastLength] = (int)i;
     1800                  }
     1801                  maskStarts[++lastLength]=(int)nEntries;
    18021802                  delete [] sort;
    18031803                  for (i=0;i<maxMasks;i++)
     
    18631863                if (masks) {
    18641864                  delete [] maskStarts;
    1865                   for (int i=0;i<maxMasks;i++)
     1865                  for (size_t i=0;i<maxMasks;i++)
    18661866                    delete [] masks[i];
    18671867                  delete [] masks;
     
    28892889  // back to char as I am old fashioned
    28902890  const char * checkC = check.c_str();
    2891   int length = strlen(checkC);
     2891  size_t length = strlen(checkC);
    28922892  while (checkC[length-1]==' ')
    28932893    length--;
    28942894  for (int i=starts[length];i<starts[length+1];i++) {
    28952895    char * thisMask = masks[i];
    2896     int k;
     2896    size_t k;
    28972897    for ( k=0;k<length;k++) {
    28982898      if (thisMask[k]!='?'&&thisMask[k]!=checkC[k])
  • stable/1.10/Clp/src/ClpMatrixBase.hpp

    r1302 r1404  
    9999      default does not allow scaling
    100100      returns non-zero if no scaling done */
    101   virtual int scale(ClpModel * model, const ClpSimplex * baseModel=NULL) const
     101  virtual int scale(ClpModel * , const ClpSimplex * =NULL) const
    102102  { return 1;}
    103103  /** Scales rowCopy if column copy scaled
    104104      Only called if scales already exist */
    105   virtual void scaleRowCopy(ClpModel * model) const
     105  virtual void scaleRowCopy(ClpModel * ) const
    106106  { }
    107107  /// Returns true if can create row copy
     
    111111      Only called if scales already exist.
    112112      Up to user to delete */
    113   inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const
     113  inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * ) const
    114114  { return this->clone();}
    115115 
     
    124124      8 - report on large and small
    125125  */
    126   virtual bool allElementsInRange(ClpModel * model,
    127                                   double smallest, double largest,
    128                                   int check=15)
     126  virtual bool allElementsInRange(ClpModel * ,
     127                                  double, double,
     128                                  int =15)
    129129  { return true;}
    130130  /** Set the dimensions of the matrix. In effect, append new empty
     
    155155      Returns non-zero if any changes.
    156156  */
    157   virtual int refresh(ClpSimplex * model)
     157  virtual int refresh(ClpSimplex * )
    158158  { return 0;}
    159159 
     
    295295  /** Returns true if can combine transposeTimes and subsetTransposeTimes
    296296      and if it would be faster */
    297   virtual bool canCombine(const ClpSimplex * model,
    298                           const CoinIndexedVector * pi) const {return false;}
     297  virtual bool canCombine(const ClpSimplex * ,
     298                          const CoinIndexedVector * ) const {return false;}
    299299  /// Updates two arrays for steepest and does devex weights (need not be coded)
    300300  virtual void transposeTimes2(const ClpSimplex * model,
  • stable/1.10/Clp/src/ClpModel.cpp

    r1344 r1404  
    32753275  }
    32763276#endif
    3277   int size = rowNames_.size();
    3278   if (size>iRow) {
     3277  size_t size = rowNames_.size();
     3278  if (size>(size_t)iRow) {
    32793279    return rowNames_[iRow];
    32803280  } else {
     
    32953295#endif
    32963296  unsigned int maxLength=lengthNames_;
    3297   int size = rowNames_.size();
    3298   if (size<=iRow)
     3297  size_t size = rowNames_.size();
     3298  if (size<=(size_t)iRow)
    32993299    rowNames_.resize(iRow+1);
    33003300  rowNames_[iRow]= name;
     
    33123312  }
    33133313#endif
    3314   int size = columnNames_.size();
    3315   if (size>iColumn) {
     3314  size_t size = columnNames_.size();
     3315  if (size>(size_t)iColumn) {
    33163316    return columnNames_[iColumn];
    33173317  } else {
     
    33323332#endif
    33333333  unsigned int maxLength=lengthNames_;
    3334   int size = columnNames_.size();
    3335   if (size<=iColumn)
     3334  size_t size = columnNames_.size();
     3335  if (size<=(size_t)iColumn)
    33363336    columnNames_.resize(iColumn+1);
    33373337  columnNames_[iColumn]= name;
     
    33453345{
    33463346  unsigned int maxLength=lengthNames_;
    3347   int size = rowNames_.size();
    3348   if (size!=numberRows_)
     3347  size_t size = rowNames_.size();
     3348  if (size!=(size_t)numberRows_)
    33493349    rowNames_.resize(numberRows_);
    33503350  int iRow;
     
    33613361{
    33623362  unsigned int maxLength=lengthNames_;
    3363   int size = columnNames_.size();
    3364   if (size!=numberColumns_)
     3363  size_t size = columnNames_.size();
     3364  if (size!=(size_t)numberColumns_)
    33653365    columnNames_.resize(numberColumns_);
    33663366  int iColumn;
     
    33773377{
    33783378  unsigned int maxLength=lengthNames_;
    3379   int size = rowNames_.size();
    3380   if (size!=numberRows_)
     3379  size_t size = rowNames_.size();
     3380  if (size!=(size_t)numberRows_)
    33813381    rowNames_.resize(numberRows_);
    33823382  int iRow;
     
    34003400{
    34013401  unsigned int maxLength=lengthNames_;
    3402   int size = columnNames_.size();
    3403   if (size!=numberColumns_)
     3402  size_t size = columnNames_.size();
     3403  if (size!=(size_t)numberColumns_)
    34043404    columnNames_.resize(numberColumns_);
    34053405  int iColumn;
     
    36353635  if (lengthNames()) {
    36363636    rowNames = new char * [numberRows_+1];
    3637     int numberNames = rowNames_.size();
    3638     numberNames = CoinMin(numberRows_,numberNames);
    3639     int iRow;
     3637    size_t numberNames = rowNames_.size();
     3638    numberNames = CoinMin((size_t)numberRows_,numberNames);
     3639    size_t iRow;
    36403640    for (iRow=0;iRow<numberNames;iRow++) {
    36413641      rowNames[iRow] =
    3642         CoinStrdup(rowName(iRow).c_str());
     3642        CoinStrdup(rowName((int)iRow).c_str());
    36433643#ifdef STRIPBLANKS
    36443644      char * xx = rowNames[iRow];
     
    36543654    }
    36553655    char name[9];
    3656     for ( ;iRow<numberRows_;iRow++) {
    3657       sprintf(name,"R%7.7d",iRow);
     3656    for ( ;iRow<(size_t)numberRows_;iRow++) {
     3657      sprintf(name,"R%7.7d",(int)iRow);
    36583658      rowNames[iRow]=CoinStrdup(name);
    36593659    }
     
    36693669  if (lengthNames()) {
    36703670    columnNames = new char * [numberColumns_];
    3671     int numberNames = columnNames_.size();
    3672     numberNames = CoinMin(numberColumns_,numberNames);
    3673     int iColumn;
     3671    size_t numberNames = columnNames_.size();
     3672    numberNames = CoinMin((size_t)numberColumns_,numberNames);
     3673    size_t iColumn;
    36743674    for (iColumn=0;iColumn<numberNames;iColumn++) {
    36753675      columnNames[iColumn] =
    3676         CoinStrdup(columnName(iColumn).c_str());
     3676        CoinStrdup(columnName((int)iColumn).c_str());
    36773677#ifdef STRIPBLANKS
    36783678      char * xx = columnNames[iColumn];
     
    36883688    }
    36893689    char name[9];
    3690     for ( ;iColumn<numberColumns_;iColumn++) {
    3691       sprintf(name,"C%7.7d",iColumn);
     3690    for ( ;iColumn<(size_t)numberColumns_;iColumn++) {
     3691      sprintf(name,"C%7.7d",(int)iColumn);
    36923692      columnNames[iColumn]=CoinStrdup(name);
    36933693    }
     
    38573857    char temp[30];
    38583858    strcpy(temp,rowName(i).c_str());
    3859     int length = strlen(temp);
    3860     for (int j=0;j<length;j++) {
     3859    size_t length = strlen(temp);
     3860    for (size_t j=0;j<length;j++) {
    38613861      if (temp[j]=='-')
    38623862        temp[j]='_';
     
    38673867    char temp[30];
    38683868    strcpy(temp,columnName(i).c_str());
    3869     int length = strlen(temp);
    3870     for (int j=0;j<length;j++) {
     3869    size_t length = strlen(temp);
     3870    for (size_t j=0;j<length;j++) {
    38713871      if (temp[j]=='-')
    38723872        temp[j]='_';
  • stable/1.10/Clp/src/ClpSimplex.cpp

    r1400 r1404  
    59245924int outDoubleArray(double * array, int length, FILE * fp)
    59255925{
    5926   int numberWritten;
     5926  size_t numberWritten;
    59275927  if (array&&length) {
    59285928    numberWritten = fwrite(&length,sizeof(int),1,fp);
     
    59305930      return 1;
    59315931    numberWritten = fwrite(array,sizeof(double),length,fp);
    5932     if (numberWritten!=length)
     5932    if (numberWritten!=(size_t)length)
    59335933      return 1;
    59345934  } else {
     
    59475947  if (fp) {
    59485948    Clp_scalars scalars;
    5949     CoinBigIndex numberWritten;
     5949    size_t numberWritten;
    59505950    // Fill in scalars
    59515951    scalars.optimizationDirection = optimizationDirection_;
     
    59815981    if (numberWritten!=1)
    59825982      return 1;
    5983     CoinBigIndex length;
     5983    size_t length;
    59845984#ifndef CLP_NO_STD
    59855985    int i;
     
    60596059      }
    60606060      numberWritten = fwrite(array,lengthNames_+1,numberRows_,fp);
    6061       if (numberWritten!=numberRows_)
     6061      if (numberWritten!=(size_t)numberRows_)
    60626062        return 1;
    60636063      put=array;
     
    60696069      }
    60706070      numberWritten = fwrite(array,lengthNames_+1,numberColumns_,fp);
    6071       if (numberWritten!=numberColumns_)
     6071      if (numberWritten!=(size_t)numberColumns_)
    60726072        return 1;
    60736073      delete [] array;
     
    60796079      numberWritten=fwrite(&marker,sizeof(int),1,fp);
    60806080      numberWritten = fwrite(integerType_,1,numberColumns_,fp);
    6081       if (numberWritten!=numberColumns_)
     6081      if (numberWritten!=(size_t)numberColumns_)
    60826082        return 1;
    60836083    } else {
     
    61056105    numberWritten = fwrite(matrix_->getVectorStarts(),
    61066106                           sizeof(int),numberColumns_+1,fp);
    6107     if (numberWritten!=numberColumns_+1)
     6107    if (numberWritten!=(size_t)numberColumns_+1)
    61086108      return 1;
    61096109    numberWritten = fwrite(matrix_->getVectorLengths(),
    61106110                           sizeof(int),numberColumns_,fp);
    6111     if (numberWritten!=numberColumns_)
     6111    if (numberWritten!=(size_t)numberColumns_)
    61126112      return 1;
    61136113    // finished
     
    61216121int inDoubleArray(double * &array, int length, FILE * fp)
    61226122{
    6123   int numberRead;
     6123  size_t numberRead;
    61246124  int length2;
    61256125  numberRead = fread(&length2,sizeof(int),1,fp);
     
    61326132    array = new double[length];
    61336133    numberRead = fread(array,sizeof(double),length,fp);
    6134     if (numberRead!=length)
     6134    if (numberRead!=(size_t)length)
    61356135      return 1;
    61366136  }
     
    61606160    factorization_->sparseThreshold(1);
    61616161    Clp_scalars scalars;
    6162     CoinBigIndex numberRead;
     6162    size_t numberRead;
    61636163
    61646164    // get scalars
     
    61926192    specialOptions_ = scalars.specialOptions;
    61936193    // strings
    6194     CoinBigIndex length;
     6194    size_t length;
    61956195#ifndef CLP_NO_STD
    61966196    for (i=0;i<ClpLastStrParam;i++) {
     
    62556255        return 1;
    62566256    if (length) {
    6257       if (length!=numberRows_+numberColumns_)
     6257      if (length!=(size_t)(numberRows_+numberColumns_))
    62586258        return 1;
    62596259      status_ = new char unsigned[length];
     
    62686268      char * get = array;
    62696269      numberRead = fread(array,lengthNames_+1,numberRows_,fp);
    6270       if (numberRead!=numberRows_)
     6270      if (numberRead!=(size_t)numberRows_)
    62716271        return 1;
    62726272      rowNames_ = std::vector<std::string> ();
     
    62786278      get = array;
    62796279      numberRead = fread(array,lengthNames_+1,numberColumns_,fp);
    6280       if (numberRead!=numberColumns_)
     6280      if (numberRead!=(size_t)numberColumns_)
    62816281        return 1;
    62826282      columnNames_ = std::vector<std::string> ();
     
    63006300      integerType_ = new char [numberColumns_];
    63016301      numberRead = fread(integerType_,1,numberColumns_,fp);
    6302       if (numberRead!=numberColumns_)
     6302      if (numberRead!=(size_t)numberColumns_)
    63036303        return 1;
    63046304    } else {
     
    63606360      return 1;
    63616361    numberRead = fread(starts, sizeof(int),numberColumns_+1,fp);
    6362     if (numberRead!=numberColumns_+1)
     6362    if (numberRead!=(size_t)numberColumns_+1)
    63636363      return 1;
    63646364    numberRead = fread(lengths, sizeof(int),numberColumns_,fp);
    6365     if (numberRead!=numberColumns_)
     6365    if (numberRead!=(size_t)numberColumns_)
    63666366      return 1;
    63676367    // assign matrix
     
    63736373    for (i=0;i<numberColumns_;i++) {
    63746374      int start = starts[i];
    6375       starts[i]=length;
     6375      starts[i]=(int)length;
    63766376      for (CoinBigIndex j=start;j<start+lengths[i];j++) {
    63776377        elements[length]=elements[j];
    63786378        indices[length++]=indices[j];
    63796379      }
    6380       lengths[i]=length-starts[i];
    6381     }
    6382     starts[numberColumns_]=length;
     6380      lengths[i]=(int)length-starts[i];
     6381    }
     6382    starts[numberColumns_]=(int)length;
    63836383    matrix->assignMatrix(true, numberRows_, numberColumns_,
    6384                          length, elements, indices, starts, lengths);
     6384                         (CoinBigIndex)length, elements, indices, starts, lengths);
    63856385    // and transfer to Clp
    63866386    matrix_ = new ClpPackedMatrix(matrix);
  • stable/1.10/Clp/src/ClpSimplexDual.cpp

    r1359 r1404  
    43254325    handler_->message()<<CoinMessageEol;
    43264326  }
     4327  double approximateObjective=objectiveValue_;
    43274328#ifdef CLP_REPORT_PROGRESS
    43284329    if (ixxxxxx>=ixxyyyy-4&&ixxxxxx<=ixxyyyy) {
     
    50055006  if (alphaAccuracy_>0.0)
    50065007      alphaAccuracy_=1.0;
     5008  // If we are stopping - use plausible objective
     5009  // Maybe only in fast dual
     5010  if (problemStatus_>2)
     5011    objectiveValue_ = approximateObjective;
    50075012}
    50085013/* While updateDualsInDual sees what effect is of flip
  • stable/1.10/Clp/src/Clp_C_Interface.cpp

    r1231 r1404  
    240240      prefix, numcols, numrows);
    241241    printf("%s model = %p, start = %p, index = %p, value = %p\n",
    242       prefix, (void*)model, (void*)start, (void*)index, (void*)value);
     242           prefix, reinterpret_cast<const void *>(model), reinterpret_cast<const void *>(start), reinterpret_cast<const void *>(index), reinterpret_cast<const void *>(value));
    243243    printf("%s collb = %p, colub = %p, obj = %p, rowlb = %p, rowub = %p\n",
    244       prefix, (void*)collb, (void*)colub, (void*)obj, (void*)rowlb, (void*)rowub);
     244           prefix, reinterpret_cast<const void *>(collb), reinterpret_cast<const void *>(colub), reinterpret_cast<const void *>(obj), reinterpret_cast<const void *>(rowlb), reinterpret_cast<const void *>(rowub));
    245245  }
    246246  model->model_->loadProblem(numcols,numrows,start,index,value,
     
    11301130    prefix, numcols, numrows, numelem);
    11311131  printf("%s model = %p, start = %p, index = %p, value = %p\n",
    1132     prefix, (void*)model, (void*)start, (void*)index, (void*)value);
     1132         prefix, reinterpret_cast<const void *>(model), reinterpret_cast<const void *>(start), reinterpret_cast<const void *>(index), reinterpret_cast<const void *>(value));
    11331133  clp_simplex->matrix()->dumpMatrix(NULL);
    11341134  {
     
    11421142 
    11431143  printf("%s collb = %p, colub = %p, obj = %p, rowlb = %p, rowub = %p\n",
    1144     prefix, (void*)collb, (void*)colub, (void*)obj, (void*)rowlb, (void*)rowub);
     1144         prefix, reinterpret_cast<const void *>(collb), reinterpret_cast<const void *>(colub), reinterpret_cast<const void *>(obj), reinterpret_cast<const void *>(rowlb), reinterpret_cast<const void *>(rowub));
    11451145  printf("%s optimization direction = %g\n",prefix, Clp_optimizationDirection(model));
    11461146  printf("  (1 - minimize, -1 - maximize, 0 - ignore)\n");
  • stable/1.10/Clp/src/Makefile.am

    r1344 r1404  
    162162        ClpQuadraticObjective.hpp \
    163163        ClpSimplex.hpp \
     164        ClpSimplexDual.hpp \
    164165        ClpSimplexNonlinear.hpp \
    165166        ClpSimplexOther.hpp \
     
    167168        ClpSolve.hpp \
    168169        CbcOrClpParam.hpp \
     170        CbcOrClpParam.cpp \
    169171        Idiot.hpp
    170172
  • stable/1.10/Clp/src/Makefile.in

    r1344 r1404  
    412412        ClpQuadraticObjective.hpp \
    413413        ClpSimplex.hpp \
     414        ClpSimplexDual.hpp \
    414415        ClpSimplexNonlinear.hpp \
    415416        ClpSimplexOther.hpp \
     
    417418        ClpSolve.hpp \
    418419        CbcOrClpParam.hpp \
     420        CbcOrClpParam.cpp \
    419421        Idiot.hpp
    420422
  • stable/1.10/Clp/src/MyMessageHandler.cpp

    r1321 r1404  
    126126
    127127        // Want maximum of 10 solutions, so if more then 10 get rid of oldest
    128         int numExtremePointsSaved = feasibleExtremePoints_.size();
     128        size_t numExtremePointsSaved = feasibleExtremePoints_.size();
    129129        if ( numExtremePointsSaved>=10 ) {
    130130          feasibleExtremePoints_.pop_back();
    131           assert( feasibleExtremePoints_.size() ==
    132                   static_cast<unsigned int> (numExtremePointsSaved)-1 );
     131          assert( feasibleExtremePoints_.size() + 1 == numExtremePointsSaved );
    133132        };
    134133
  • stable/1.10/Clp/src/unitTest.cpp

    r1344 r1404  
    820820    // Write saved solutions
    821821    int nc = model.getNumCols();
    822     int s;
     822    size_t s;
    823823    std::deque<StdVectorDouble> fep = messageHandler.getFeasibleExtremePoints();
    824     int numSavedSolutions = fep.size();
     824    size_t numSavedSolutions = fep.size();
    825825    for ( s=0; s<numSavedSolutions; ++s ) {
    826826      const StdVectorDouble & solnVec = fep[s];
     
    19681968    // Create a structured model
    19691969    CoinStructuredModel structured;
    1970     int numberBlocks=5;
    1971     for (int i=0;i<numberBlocks;i++) {
     1970    char numberBlocks=5;
     1971    for (char i=0;i<numberBlocks;i++) {
    19721972      std::string topName="row_master";
    19731973      std::string blockName="block_";
    1974       char bName = 'a'+i;
     1974      char bName = (char)('a'+i);
    19751975      blockName.append(1,bName);
    19761976      structured.addBlock(topName,blockName,top);
     
    19961996    CoinStructuredModel structured2;
    19971997    numberBlocks=3;
    1998     for (int i=0;i<numberBlocks;i++) {
     1998    for (char i=0;i<numberBlocks;i++) {
    19991999      std::string blockName="block_";
    2000       char bName = 'a'+i;
     2000      char bName = (char)('a'+i);
    20012001      blockName.append(1,bName);
    20022002      structured2.addBlock(blockName,blockName,structured);
Note: See TracChangeset for help on using the changeset viewer.