Changeset 2372 for trunk


Ignore:
Timestamp:
May 2, 2018 7:08:26 AM (15 months ago)
Author:
forrest
Message:

find s1 integers

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcSolver.cpp

    r2365 r2372  
    41224122                                        char * prohibited = new char[numberColumns];
    41234123                                        memset(prohibited, 0, numberColumns);
    4124                                         int n = sosStart[numberSOS];
    4125                                         for (int i = 0; i < n; i++) {
    4126                                             int iColumn = sosIndices[i];
    4127                                             prohibited[iColumn] = 1;
     4124                                        // worth looking to see if any members can be made integer
     4125
     4126                                        int numberRows = saveSolver->getNumRows();
     4127                                        const CoinPackedMatrix * matrixByCol = saveSolver->getMatrixByCol();
     4128                                        const double * element = matrixByCol->getElements();
     4129                                        const int * row = matrixByCol->getIndices();
     4130                                        const CoinBigIndex * columnStart = matrixByCol->getVectorStarts();
     4131                                        const int * columnLength = matrixByCol->getVectorLengths();
     4132                                        const double * columnLower = saveSolver->getColLower();
     4133                                        const double * columnUpper = saveSolver->getColUpper();
     4134                                        const double * rowLower = saveSolver->getRowLower();
     4135                                        const double * rowUpper = saveSolver->getRowUpper();
     4136                                        double * sameElement = new double [numberRows];
     4137                                        int * rowCount = new int [2*numberRows];
     4138                                        int * rowUsed = rowCount+numberRows;
     4139                                        memset(sameElement,0,numberRows*sizeof(double));
     4140                                        memset(rowCount,0,numberRows*sizeof(int));
     4141                                        int numberInteresting1=0;
     4142                                        int numberInteresting2=0;
     4143                                        int numberChanged=0;
     4144                                        for (int iSet=0;iSet<numberSOS;iSet++) {
     4145                                          if (sosType[iSet]!=1) {
     4146                                            for (int i = sosStart[iSet];
     4147                                                 i < sosStart[iSet+1]; i++) {
     4148                                              numberInteresting2++;
     4149                                              int iColumn = sosIndices[i];
     4150                                              prohibited[iColumn] = 1;
     4151                                            }
     4152                                          } else {
     4153                                            int nUsed=0;
     4154                                            for (int i = sosStart[iSet];
     4155                                                 i < sosStart[iSet+1]; i++) {
     4156                                              int iColumn = sosIndices[i];
     4157                                              for (CoinBigIndex j=columnStart[iColumn];
     4158                                                   j<columnStart[iColumn]+columnLength[iColumn];j++) {
     4159                                                int iRow=row[j];
     4160                                                double el=element[j];
     4161                                                if (rowCount[iRow]) {
     4162                                                  if (el!=sameElement[iRow])
     4163                                                    sameElement[iRow]=0.0;
     4164                                                } else {
     4165                                                  sameElement[iRow]=el;
     4166                                                  rowUsed[nUsed++]=iRow;
     4167                                                }
     4168                                                rowCount[iRow]++;
     4169                                              }
     4170                                            }
     4171                                            int nInSet=sosStart[iSet+1]-sosStart[iSet];
     4172                                            double nonzeroValue=COIN_DBL_MAX;
     4173                                            for (int iUsed=0;iUsed<nUsed;iUsed++) {
     4174                                              int iRow=rowUsed[iUsed];
     4175                                              if (rowCount[iRow]==nInSet&&sameElement[iRow]&&rowLower[iRow]==rowUpper[iRow]) {
     4176                                                // all entries must be 0.0 or xx
     4177                                                nonzeroValue=rowLower[iRow]/sameElement[iRow];
     4178                                              }
     4179                                              rowCount[iRow]=0;
     4180                                              sameElement[iRow]=0.0;
     4181                                            }
     4182                                            if (nonzeroValue!=COIN_DBL_MAX) {
     4183                                              // could do scaling otherwise
     4184                                              if (fabs(nonzeroValue-1.0)<1.0e-8) {
     4185                                                for (int i = sosStart[iSet];
     4186                                                     i < sosStart[iSet+1]; i++) {
     4187                                                  int iColumn = sosIndices[i];
     4188                                                  if (columnUpper[iColumn]<0.0||columnLower[iColumn]>1.0) {
     4189                                                    printf("sos says infeasible\n");
     4190                                                  }
     4191                                                  if (!saveSolver->isInteger(iColumn)) {
     4192                                                    numberChanged++;
     4193                                                    saveSolver->setInteger(iColumn);
     4194                                                  }
     4195                                                  if (columnUpper[iColumn]<1.0)
     4196                                                    saveSolver->setColUpper(iColumn,0.0);
     4197                                                  else
     4198                                                    saveSolver->setColUpper(iColumn,1.0);
     4199                                                  if (columnLower[iColumn]>0.0)
     4200                                                    saveSolver->setColLower(iColumn,1.0);
     4201                                                  else
     4202                                                    saveSolver->setColLower(iColumn,0.0);
     4203#ifndef DO_LESS_PROHIBITED
     4204                                                  prohibited[iColumn] = 1;
     4205#endif
     4206                                                }
     4207                                              } else {
     4208                                                for (int i = sosStart[iSet];
     4209                                                     i < sosStart[iSet+1]; i++) {
     4210                                                  int iColumn = sosIndices[i];
     4211#ifndef DO_LESS_PROHIBITED
     4212                                                  prohibited[iColumn] = 1;
     4213#endif
     4214                                                }
     4215                                              }
     4216                                            } else {
     4217                                              for (int i = sosStart[iSet];
     4218                                                   i < sosStart[iSet+1]; i++) {
     4219                                                int iColumn = sosIndices[i];
     4220                                                if (!saveSolver->isInteger(iColumn))
     4221                                                  numberInteresting1++;
     4222#ifdef DO_LESS_PROHIBITED
     4223                                                if (!saveSolver->isInteger(iColumn))
     4224#endif
     4225                                                  prohibited[iColumn] = 1;
     4226                                              }
     4227                                            }
     4228                                          }
    41284229                                        }
     4230                                        if (numberChanged||numberInteresting1||numberInteresting2) {
     4231                                          sprintf(generalPrint,"%d variables in SOS1 sets made integer, %d non integer in SOS1, %d in SOS2\n",
     4232                                                numberChanged,numberInteresting1,numberInteresting2);
     4233                                          generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4234                                            << generalPrint
     4235                                            << CoinMessageEol;
     4236                                        }
     4237                                        delete [] sameElement;
     4238                                        delete [] rowCount;
    41294239                                        process.passInProhibited(prohibited, numberColumns);
    41304240                                        delete [] prohibited;
     
    41904300                                                for (int i = 0; i < n; i++) {
    41914301                                                    int iColumn = which[i];
    4192                                                     prohibited[iColumn] = 1;
     4302#ifdef DO_LESS_PROHIBITED
     4303                                                    if (!saveSolver->isInteger(iColumn))
     4304#endif
     4305                                                      prohibited[iColumn] = 1;
    41934306                                                    numberProhibited++;
    41944307                                                }
     
    43894502                                        //int type = setInfo[i].setType();
    43904503                                        int n = setInfo[i].numberEntries();
    4391                                         int * which = const_cast<int *>(setInfo[i].which());
     4504                                        int * which = setInfo[i].modifiableWhich();
     4505#ifndef DO_LESS_PROHIBITED
    43924506                                        for (int j=0;j<n;j++) {
    43934507                                          int iColumn = which[j];
     
    43964510                                          which[j]=iColumn;
    43974511                                        }
     4512#else
     4513                                        double * weights = setInfo[i].modifiableWeights();
     4514                                        int n2=0;
     4515                                        for (int j=0;j<n;j++) {
     4516                                          int iColumn = which[j];
     4517                                          iColumn=back[iColumn];
     4518                                          if (iColumn>=0) {
     4519                                            which[n2]=iColumn;
     4520                                            weights[n2++]=weights[j];
     4521                                          }
     4522                                        }
     4523                                        setInfo[i].setNumberEntries(n2);
     4524#endif
    43984525                                      }
    43994526                                      delete [] back;
     
    57985925                                        }
    57995926                                        if (nMissing) {
     5927#ifndef DO_LESS_PROHIBITED
    58005928                                            sprintf(generalPrint, "%d SOS variables vanished due to pre processing? - check validity?", nMissing);
     5929#else
     5930                                            sprintf(generalPrint, "%d SOS variables eliminated by pre processing", nMissing);
     5931#endif
    58015932                                            generalMessageHandler->message(CLP_GENERAL, generalMessages)
    58025933                                            << generalPrint
     
    58555986                                                // Really need better checks
    58565987                                                int nMissing = 0;
     5988#ifndef DO_LESS_PROHIBITED
    58575989                                                int n = sosStart[numberSOS];
    58585990                                                for (i = 0; i < n; i++) {
     
    58645996                                                        nMissing++;
    58655997                                                }
     5998#else
     5999                                                int startSet=0;
     6000                                                int iPut=0;
     6001                                                for (int j = 0; j < numberSOS; j++) {
     6002                                                  for (i = startSet; i < sosStart[j+1]; i++) {
     6003                                                    int iColumn = sosIndices[i];
     6004                                                    int jColumn = back[iColumn];
     6005                                                    if (jColumn >= 0) {
     6006                                                      sosReference[iPut]=sosReference[i];
     6007                                                      sosIndices[iPut++] = jColumn;
     6008                                                    } else {
     6009                                                        nMissing++;
     6010                                                    }
     6011                                                  }
     6012                                                  startSet=sosStart[j+1];
     6013                                                  sosStart[j+1]=iPut;
     6014                                                }
     6015#endif
    58666016                                                delete [] back;
    58676017                                                if (nMissing) {
    5868                                                     sprintf(generalPrint, "%d SOS variables vanished due to pre processing? - check validity?", nMissing);
    5869                                                     generalMessageHandler->message(CLP_GENERAL, generalMessages)
     6018#ifndef DO_LESS_PROHIBITED
     6019                                                  sprintf(generalPrint, "%d SOS variables vanished due to pre processing? - check validity?", nMissing);
     6020#else
     6021                                                  sprintf(generalPrint, "%d SOS variables eliminated by pre processing", nMissing);
     6022#endif
     6023                                                  generalMessageHandler->message(CLP_GENERAL, generalMessages)
    58706024                                                    << generalPrint
    58716025                                                    << CoinMessageEol;
Note: See TracChangeset for help on using the changeset viewer.