Ignore:
Timestamp:
Jul 21, 2013 5:05:45 AM (8 years ago)
Author:
forrest
Message:

more options, copy statistics structure analysis
start coding of "switch" variables i.e. badly scaled ints or hi/lo
changes to allow more influence on small branch and bound
changes to get correct printout with threads

File:
1 edited

Legend:

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

    r1937 r1943  
    38763876                                          process.setOptions(2+4+8); // no cuts
    38773877                                        cbcPreProcessPointer = & process;
     3878                                        int saveOptions = osiclp->getModelPtr()->moreSpecialOptions();
     3879                                        if ((model_.specialOptions()&16777216)!=0&&
     3880                                            model_.getCutoff()>1.0e30) {
     3881                                          osiclp->getModelPtr()->setMoreSpecialOptions(saveOptions|262144);
     3882                                        }
    38783883                                        solver2 = process.preProcessNonDefault(*saveSolver, translate[preProcess], numberPasses,
    38793884                                                                               tunePreProcess);
     
    38813886                                          saveSolver->writeMps("before");*/
    38823887                                        osiclp->getModelPtr()->setPerturbation(savePerturbation);
     3888                                        osiclp->getModelPtr()->setMoreSpecialOptions(saveOptions);
    38833889                                    }
    38843890#elif CBC_OTHER_SOLVER==1
     
    49534959                                   double obj;
    49544960                                   int status = computeCompleteSolution( babModel_, colNames, mipStart, &x[0], obj );
    4955                                    if (!status)
     4961                                   if (!status) {
    49564962                                     babModel_->setBestSolution( &x[0], static_cast<int>(x.size()), obj, false );
     4963                                     babModel_->setSolutionCount(1);
     4964                                   }
    49574965                                }
    49584966
     
    61716179                                if (biLinearProblem)
    61726180                                  babModel_->setSpecialOptions(babModel_->specialOptions() &(~(512|32768)));
     6181                                babModel_->setMoreSpecialOptions2(parameters_[whichParam(CBC_PARAM_INT_MOREMOREMIPOPTIONS, numberParameters_, parameters_)].intValue());
    61736182                                babModel_->branchAndBound(statistics);
    61746183                                if (truncateColumns<babModel_->solver()->getNumCols()) {
     
    94329441    delete [] numberExact;
    94339442}
     9443static void sortOnOther(int * column,
     9444                 const CoinBigIndex * rowStart,
     9445                 int * order,
     9446                 int * other,
     9447                 int nRow,
     9448                 int nInRow,
     9449                 int where)
     9450{
     9451     if (nRow < 2 || where >= nInRow)
     9452          return;
     9453     // do initial sort
     9454     int kRow;
     9455     int iRow;
     9456     for ( kRow = 0; kRow < nRow; kRow++) {
     9457          iRow = order[kRow];
     9458          other[kRow] = column[rowStart[iRow] + where];
     9459     }
     9460     CoinSort_2(other, other + nRow, order);
     9461     int first = 0;
     9462     iRow = order[0];
     9463     int firstC = column[rowStart[iRow] + where];
     9464     kRow = 1;
     9465     while (kRow < nRow) {
     9466          int lastC = 9999999;;
     9467          for (; kRow < nRow + 1; kRow++) {
     9468               if (kRow < nRow) {
     9469                    iRow = order[kRow];
     9470                    lastC = column[rowStart[iRow] + where];
     9471               } else {
     9472                    lastC = 9999999;
     9473               }
     9474               if (lastC > firstC)
     9475                    break;
     9476          }
     9477          // sort
     9478          sortOnOther(column, rowStart, order + first, other, kRow - first,
     9479                      nInRow, where + 1);
     9480          firstC = lastC;
     9481          first = kRow;
     9482     }
     9483}
    94349484static void statistics(ClpSimplex * originalModel, ClpSimplex * model)
    94359485{
    9436     int numberColumns = originalModel->numberColumns();
    9437     const char * integerInformation  = originalModel->integerInformation();
    9438     const double * columnLower = originalModel->columnLower();
    9439     const double * columnUpper = originalModel->columnUpper();
    9440     int numberIntegers = 0;
    9441     int numberBinary = 0;
    9442     int iRow, iColumn;
    9443     if (integerInformation) {
    9444         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    9445             if (integerInformation[iColumn]) {
    9446                 if (columnUpper[iColumn] > columnLower[iColumn]) {
    9447                     numberIntegers++;
    9448                     if (columnUpper[iColumn] == 0.0 && columnLower[iColumn] == 1)
    9449                         numberBinary++;
    9450                 }
    9451             }
    9452         }
    9453     }
    9454     numberColumns = model->numberColumns();
    9455     int numberRows = model->numberRows();
    9456     columnLower = model->columnLower();
    9457     columnUpper = model->columnUpper();
    9458     const double * rowLower = model->rowLower();
    9459     const double * rowUpper = model->rowUpper();
    9460     const double * objective = model->objective();
    9461     CoinPackedMatrix * matrix = model->matrix();
    9462     CoinBigIndex numberElements = matrix->getNumElements();
    9463     const int * columnLength = matrix->getVectorLengths();
    9464     //const CoinBigIndex * columnStart = matrix->getVectorStarts();
    9465     const double * elementByColumn = matrix->getElements();
    9466     int * number = new int[numberRows+1];
    9467     memset(number, 0, (numberRows + 1)*sizeof(int));
    9468     int numberObjSingletons = 0;
    9469     /* cType
    9470        0 0/inf, 1 0/up, 2 lo/inf, 3 lo/up, 4 free, 5 fix, 6 -inf/0, 7 -inf/up,
    9471        8 0/1
    9472     */
    9473     int cType[9];
    9474     std::string cName[] = {"0.0->inf,", "0.0->up,", "lo->inf,", "lo->up,", "free,", "fixed,", "-inf->0.0,",
    9475                            "-inf->up,", "0.0->1.0"
    9476                           };
    9477     int nObjective = 0;
    9478     memset(cType, 0, sizeof(cType));
    9479     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    9480         int length = columnLength[iColumn];
    9481         if (length == 1 && objective[iColumn])
    9482             numberObjSingletons++;
    9483         number[length]++;
    9484         if (objective[iColumn])
    9485             nObjective++;
    9486         if (columnLower[iColumn] > -1.0e20) {
    9487             if (columnLower[iColumn] == 0.0) {
    9488                 if (columnUpper[iColumn] > 1.0e20)
    9489                     cType[0]++;
    9490                 else if (columnUpper[iColumn] == 1.0)
    9491                     cType[8]++;
    9492                 else if (columnUpper[iColumn] == 0.0)
    9493                     cType[5]++;
    9494                 else
    9495                     cType[1]++;
    9496             } else {
    9497                 if (columnUpper[iColumn] > 1.0e20)
    9498                     cType[2]++;
    9499                 else if (columnUpper[iColumn] == columnLower[iColumn])
    9500                     cType[5]++;
    9501                 else
    9502                     cType[3]++;
    9503             }
    9504         } else {
    9505             if (columnUpper[iColumn] > 1.0e20)
    9506                 cType[4]++;
    9507             else if (columnUpper[iColumn] == 0.0)
    9508                 cType[6]++;
    9509             else
    9510                 cType[7]++;
    9511         }
    9512     }
    9513     /* rType
    9514        0 E 0, 1 E 1, 2 E -1, 3 E other, 4 G 0, 5 G 1, 6 G other,
    9515        7 L 0,  8 L 1, 9 L other, 10 Range 0/1, 11 Range other, 12 free
    9516     */
    9517     int rType[13];
    9518     std::string rName[] = {"E 0.0,", "E 1.0,", "E -1.0,", "E other,", "G 0.0,", "G 1.0,", "G other,",
    9519                            "L 0.0,", "L 1.0,", "L other,", "Range 0.0->1.0,", "Range other,", "Free"
    9520                           };
    9521     memset(rType, 0, sizeof(rType));
    9522     for (iRow = 0; iRow < numberRows; iRow++) {
    9523         if (rowLower[iRow] > -1.0e20) {
    9524             if (rowLower[iRow] == 0.0) {
    9525                 if (rowUpper[iRow] > 1.0e20)
    9526                     rType[4]++;
    9527                 else if (rowUpper[iRow] == 1.0)
    9528                     rType[10]++;
    9529                 else if (rowUpper[iRow] == 0.0)
    9530                     rType[0]++;
    9531                 else
    9532                     rType[11]++;
    9533             } else if (rowLower[iRow] == 1.0) {
    9534                 if (rowUpper[iRow] > 1.0e20)
    9535                     rType[5]++;
    9536                 else if (rowUpper[iRow] == rowLower[iRow])
    9537                     rType[1]++;
    9538                 else
    9539                     rType[11]++;
    9540             } else if (rowLower[iRow] == -1.0) {
    9541                 if (rowUpper[iRow] > 1.0e20)
    9542                     rType[6]++;
    9543                 else if (rowUpper[iRow] == rowLower[iRow])
    9544                     rType[2]++;
    9545                 else
    9546                     rType[11]++;
    9547             } else {
    9548                 if (rowUpper[iRow] > 1.0e20)
    9549                     rType[6]++;
    9550                 else if (rowUpper[iRow] == rowLower[iRow])
    9551                     rType[3]++;
    9552                 else
    9553                     rType[11]++;
    9554             }
    9555         } else {
    9556             if (rowUpper[iRow] > 1.0e20)
    9557                 rType[12]++;
    9558             else if (rowUpper[iRow] == 0.0)
    9559                 rType[7]++;
    9560             else if (rowUpper[iRow] == 1.0)
    9561                 rType[8]++;
    9562             else
    9563                 rType[9]++;
    9564         }
    9565     }
    9566     // Basic statistics
    9567     printf("\n\nProblem has %d rows, %d columns (%d with objective) and %d elements\n",
    9568            numberRows, numberColumns, nObjective, numberElements);
    9569     if (number[0] + number[1]) {
    9570         printf("There are ");
    9571         if (numberObjSingletons)
    9572             printf("%d singletons with objective ", numberObjSingletons);
    9573         int numberNoObj = number[1] - numberObjSingletons;
    9574         if (numberNoObj)
    9575             printf("%d singletons with no objective ", numberNoObj);
    9576         if (number[0])
    9577             printf("** %d columns have no entries", number[0]);
    9578         printf("\n");
    9579     }
    9580     printf("Column breakdown:\n");
    9581     int k;
    9582     for (k = 0; k < static_cast<int> (sizeof(cType) / sizeof(int)); k++) {
    9583         printf("%d of type %s ", cType[k], cName[k].c_str());
    9584         if (((k + 1) % 3) == 0)
    9585             printf("\n");
    9586     }
    9587     if ((k % 3) != 0)
    9588         printf("\n");
    9589     printf("Row breakdown:\n");
    9590     for (k = 0; k < static_cast<int> (sizeof(rType) / sizeof(int)); k++) {
    9591         printf("%d of type %s ", rType[k], rName[k].c_str());
    9592         if (((k + 1) % 3) == 0)
    9593             printf("\n");
    9594     }
    9595     if ((k % 3) != 0)
    9596         printf("\n");
    9597     if (model->logLevel() < 2)
    9598         return ;
    9599     int kMax = model->logLevel() > 3 ? 1000000 : 10;
    9600     k = 0;
    9601     for (iRow = 1; iRow <= numberRows; iRow++) {
    9602         if (number[iRow]) {
    9603             k++;
    9604             printf("%d columns have %d entries\n", number[iRow], iRow);
    9605             if (k == kMax)
    9606                 break;
    9607         }
    9608     }
    9609     if (k < numberRows) {
    9610         int kk = k;
    9611         k = 0;
    9612         for (iRow = numberRows; iRow >= 1; iRow--) {
    9613             if (number[iRow]) {
    9614                 k++;
    9615                 if (k == kMax)
     9486     int numberColumns = originalModel->numberColumns();
     9487     const char * integerInformation  = originalModel->integerInformation();
     9488     const double * columnLower = originalModel->columnLower();
     9489     const double * columnUpper = originalModel->columnUpper();
     9490     int numberIntegers = 0;
     9491     int numberBinary = 0;
     9492     int iRow, iColumn;
     9493     if (integerInformation) {
     9494          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     9495               if (integerInformation[iColumn]) {
     9496                    if (columnUpper[iColumn] > columnLower[iColumn]) {
     9497                         numberIntegers++;
     9498                         if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
     9499                              numberBinary++;
     9500                    }
     9501               }
     9502          }
     9503          printf("Original problem has %d integers (%d of which binary)\n",
     9504                 numberIntegers,numberBinary);
     9505     }
     9506     numberColumns = model->numberColumns();
     9507     int numberRows = model->numberRows();
     9508     columnLower = model->columnLower();
     9509     columnUpper = model->columnUpper();
     9510     const double * rowLower = model->rowLower();
     9511     const double * rowUpper = model->rowUpper();
     9512     const double * objective = model->objective();
     9513     if (model->integerInformation()) {
     9514       const char * integerInformation  = model->integerInformation();
     9515       int numberIntegers = 0;
     9516       int numberBinary = 0;
     9517       double * obj = new double [numberColumns];
     9518       int * which = new int [numberColumns];
     9519       for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     9520         if (columnUpper[iColumn] > columnLower[iColumn]) {
     9521           if (integerInformation[iColumn]) {
     9522             numberIntegers++;
     9523             if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
     9524               numberBinary++;
     9525           }
     9526         }
     9527       }
     9528       if(numberColumns != originalModel->numberColumns())
     9529         printf("Presolved problem has %d integers (%d of which binary)\n",
     9530                numberIntegers,numberBinary);
     9531       for (int ifInt=0;ifInt<2;ifInt++) {
     9532         for (int ifAbs=0;ifAbs<2;ifAbs++) {
     9533           int numberSort=0;
     9534           int numberZero=0;
     9535           int numberDifferentObj=0;
     9536           for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     9537             if (columnUpper[iColumn] > columnLower[iColumn]) {
     9538               if (!ifInt||integerInformation[iColumn]) {
     9539                 obj[numberSort]=(ifAbs) ? fabs(objective[iColumn]) :
     9540                   objective[iColumn];
     9541                 which[numberSort++]=iColumn;
     9542                 if (!objective[iColumn])
     9543                   numberZero++;
     9544               }
     9545             }
     9546           }
     9547           CoinSort_2(obj,obj+numberSort,which);
     9548           double last=obj[0];
     9549           for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     9550             if (fabs(obj[jColumn]-last)>1.0e-12) {
     9551               numberDifferentObj++;
     9552               last=obj[jColumn];
     9553             }
     9554           }
     9555           numberDifferentObj++;
     9556           printf("==== ");
     9557           if (ifInt)
     9558             printf("for integers ");
     9559           if (!ifAbs)
     9560             printf("%d zero objective ",numberZero);
     9561           else
     9562             printf("absolute objective values ");
     9563           printf("%d different\n",numberDifferentObj);
     9564           bool saveModel=false;
     9565           int target=model->logLevel();
     9566           if (target>10000) {
     9567             if (ifInt&&!ifAbs)
     9568               saveModel=true;
     9569             target-=10000;
     9570           }
     9571
     9572           if (target<=100)
     9573             target=12;
     9574           else
     9575             target-=100;
     9576           if (numberDifferentObj<target) {
     9577             int iLast=0;
     9578             double last=obj[0];
     9579             for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     9580               if (fabs(obj[jColumn]-last)>1.0e-12) {
     9581                 printf("%d variables have objective of %g\n",
     9582                        jColumn-iLast,last);
     9583                 iLast=jColumn;
     9584                 last=obj[jColumn];
     9585               }
     9586             }
     9587             printf("%d variables have objective of %g\n",
     9588                    numberSort-iLast,last);
     9589             if (saveModel) {
     9590               int spaceNeeded=numberSort+numberDifferentObj;
     9591               int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     9592               double * elementAdd = new double[spaceNeeded];
     9593               int * rowAdd = new int[2*numberDifferentObj+1];
     9594               int * newIsInteger = rowAdd+numberDifferentObj+1;
     9595               double * objectiveNew = new double[3*numberDifferentObj];
     9596               double * lowerNew = objectiveNew+numberDifferentObj;
     9597               double * upperNew = lowerNew+numberDifferentObj;
     9598               memset(columnAdd+spaceNeeded,0,
     9599                      (numberDifferentObj+1)*sizeof(int));
     9600               ClpSimplex tempModel=*model;
     9601               int iLast=0;
     9602               double last=obj[0];
     9603               numberDifferentObj=0;
     9604               int numberElements=0;
     9605               rowAdd[0]=0;
     9606               double * objective = tempModel.objective();
     9607               for (int jColumn = 1; jColumn < numberSort+1; jColumn++) {
     9608                 if (jColumn==numberSort||fabs(obj[jColumn]-last)>1.0e-12) {
     9609                   // not if just one
     9610                   if (jColumn-iLast>1) {
     9611                     bool allInteger=integerInformation!=NULL;
     9612                     int iColumn=which[iLast];
     9613                     objectiveNew[numberDifferentObj]=objective[iColumn];
     9614                     double lower=0.0;
     9615                     double upper=0.0;
     9616                     for (int kColumn=iLast;kColumn<jColumn;kColumn++) {
     9617                       iColumn=which[kColumn];
     9618                       objective[iColumn]=0.0;
     9619                       double lowerValue=columnLower[iColumn];
     9620                       double upperValue=columnUpper[iColumn];
     9621                       double elementValue=-1.0;
     9622                       if (objectiveNew[numberDifferentObj]*objective[iColumn]<0.0) {
     9623                         lowerValue=-columnUpper[iColumn];
     9624                         upperValue=-columnLower[iColumn];
     9625                         elementValue=1.0;
     9626                       }
     9627                       columnAdd[numberElements]=iColumn;
     9628                       elementAdd[numberElements++]=elementValue;
     9629                       if (integerInformation&&!integerInformation[iColumn])
     9630                         allInteger=false;
     9631                       if (lower!=-COIN_DBL_MAX) {
     9632                         if (lowerValue!=-COIN_DBL_MAX)
     9633                           lower += lowerValue;
     9634                         else
     9635                           lower=-COIN_DBL_MAX;
     9636                       }
     9637                       if (upper!=COIN_DBL_MAX) {
     9638                         if (upperValue!=COIN_DBL_MAX)
     9639                           upper += upperValue;
     9640                         else
     9641                           upper=COIN_DBL_MAX;
     9642                       }
     9643                     }
     9644                     columnAdd[numberElements]=numberColumns+numberDifferentObj;
     9645                     elementAdd[numberElements++]=1.0;
     9646                     newIsInteger[numberDifferentObj]= (allInteger) ? 1 : 0;
     9647                     lowerNew[numberDifferentObj]=lower;
     9648                     upperNew[numberDifferentObj]=upper;
     9649                     numberDifferentObj++;
     9650                     rowAdd[numberDifferentObj]=numberElements;
     9651                   }
     9652                   iLast=jColumn;
     9653                   last=obj[jColumn];
     9654                 }
     9655               }
     9656               // add columns
     9657               tempModel.addColumns(numberDifferentObj, lowerNew, upperNew,
     9658                                    objectiveNew,
     9659                                    columnAdd+spaceNeeded, NULL, NULL);
     9660               // add constraints and make integer if all integer in group
     9661               for (int iObj=0; iObj < numberDifferentObj; iObj++) {
     9662                 lowerNew[iObj]=0.0;
     9663                 upperNew[iObj]=0.0;
     9664                 if (newIsInteger[iObj])
     9665                   tempModel.setInteger(numberColumns+iObj);
     9666               }
     9667               tempModel.addRows(numberDifferentObj, lowerNew, upperNew,
     9668                                 rowAdd,columnAdd,elementAdd);
     9669               delete [] columnAdd;
     9670               delete [] elementAdd;
     9671               delete [] rowAdd;
     9672               delete [] objectiveNew;
     9673               // save
     9674               std::string tempName = model->problemName();
     9675               if (ifInt)
     9676                 tempName += "_int";
     9677               if (ifAbs)
     9678                 tempName += "_abs";
     9679               tempName += ".mps";
     9680               tempModel.writeMps(tempName.c_str());
     9681             }
     9682           }
     9683         }
     9684       }
     9685       delete [] which;
     9686       delete [] obj;
     9687       printf("===== end objective counts\n");
     9688     }
     9689     CoinPackedMatrix * matrix = model->matrix();
     9690     CoinBigIndex numberElements = matrix->getNumElements();
     9691     const int * columnLength = matrix->getVectorLengths();
     9692     //const CoinBigIndex * columnStart = matrix->getVectorStarts();
     9693     const double * elementByColumn = matrix->getElements();
     9694     int * number = new int[numberRows+1];
     9695     memset(number, 0, (numberRows + 1)*sizeof(int));
     9696     int numberObjSingletons = 0;
     9697     /* cType
     9698        0 0/inf, 1 0/up, 2 lo/inf, 3 lo/up, 4 free, 5 fix, 6 -inf/0, 7 -inf/up,
     9699        8 0/1
     9700     */
     9701     int cType[9];
     9702     std::string cName[] = {"0.0->inf,", "0.0->up,", "lo->inf,", "lo->up,", "free,", "fixed,", "-inf->0.0,",
     9703                            "-inf->up,", "0.0->1.0"
     9704                           };
     9705     int nObjective = 0;
     9706     memset(cType, 0, sizeof(cType));
     9707     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     9708          int length = columnLength[iColumn];
     9709          if (length == 1 && objective[iColumn])
     9710               numberObjSingletons++;
     9711          number[length]++;
     9712          if (objective[iColumn])
     9713               nObjective++;
     9714          if (columnLower[iColumn] > -1.0e20) {
     9715               if (columnLower[iColumn] == 0.0) {
     9716                    if (columnUpper[iColumn] > 1.0e20)
     9717                         cType[0]++;
     9718                    else if (columnUpper[iColumn] == 1.0)
     9719                         cType[8]++;
     9720                    else if (columnUpper[iColumn] == 0.0)
     9721                         cType[5]++;
     9722                    else
     9723                         cType[1]++;
     9724               } else {
     9725                    if (columnUpper[iColumn] > 1.0e20)
     9726                         cType[2]++;
     9727                    else if (columnUpper[iColumn] == columnLower[iColumn])
     9728                         cType[5]++;
     9729                    else
     9730                         cType[3]++;
     9731               }
     9732          } else {
     9733               if (columnUpper[iColumn] > 1.0e20)
     9734                    cType[4]++;
     9735               else if (columnUpper[iColumn] == 0.0)
     9736                    cType[6]++;
     9737               else
     9738                    cType[7]++;
     9739          }
     9740     }
     9741     /* rType
     9742        0 E 0, 1 E 1, 2 E -1, 3 E other, 4 G 0, 5 G 1, 6 G other,
     9743        7 L 0,  8 L 1, 9 L other, 10 Range 0/1, 11 Range other, 12 free
     9744     */
     9745     int rType[13];
     9746     std::string rName[] = {"E 0.0,", "E 1.0,", "E -1.0,", "E other,", "G 0.0,", "G 1.0,", "G other,",
     9747                            "L 0.0,", "L 1.0,", "L other,", "Range 0.0->1.0,", "Range other,", "Free"
     9748                           };
     9749     memset(rType, 0, sizeof(rType));
     9750     for (iRow = 0; iRow < numberRows; iRow++) {
     9751          if (rowLower[iRow] > -1.0e20) {
     9752               if (rowLower[iRow] == 0.0) {
     9753                    if (rowUpper[iRow] > 1.0e20)
     9754                         rType[4]++;
     9755                    else if (rowUpper[iRow] == 1.0)
     9756                         rType[10]++;
     9757                    else if (rowUpper[iRow] == 0.0)
     9758                         rType[0]++;
     9759                    else
     9760                         rType[11]++;
     9761               } else if (rowLower[iRow] == 1.0) {
     9762                    if (rowUpper[iRow] > 1.0e20)
     9763                         rType[5]++;
     9764                    else if (rowUpper[iRow] == rowLower[iRow])
     9765                         rType[1]++;
     9766                    else
     9767                         rType[11]++;
     9768               } else if (rowLower[iRow] == -1.0) {
     9769                    if (rowUpper[iRow] > 1.0e20)
     9770                         rType[6]++;
     9771                    else if (rowUpper[iRow] == rowLower[iRow])
     9772                         rType[2]++;
     9773                    else
     9774                         rType[11]++;
     9775               } else {
     9776                    if (rowUpper[iRow] > 1.0e20)
     9777                         rType[6]++;
     9778                    else if (rowUpper[iRow] == rowLower[iRow])
     9779                         rType[3]++;
     9780                    else
     9781                         rType[11]++;
     9782               }
     9783          } else {
     9784               if (rowUpper[iRow] > 1.0e20)
     9785                    rType[12]++;
     9786               else if (rowUpper[iRow] == 0.0)
     9787                    rType[7]++;
     9788               else if (rowUpper[iRow] == 1.0)
     9789                    rType[8]++;
     9790               else
     9791                    rType[9]++;
     9792          }
     9793     }
     9794     // Basic statistics
     9795     printf("\n\nProblem has %d rows, %d columns (%d with objective) and %d elements\n",
     9796            numberRows, numberColumns, nObjective, numberElements);
     9797     if (number[0] + number[1]) {
     9798          printf("There are ");
     9799          if (numberObjSingletons)
     9800               printf("%d singletons with objective ", numberObjSingletons);
     9801          int numberNoObj = number[1] - numberObjSingletons;
     9802          if (numberNoObj)
     9803               printf("%d singletons with no objective ", numberNoObj);
     9804          if (number[0])
     9805               printf("** %d columns have no entries", number[0]);
     9806          printf("\n");
     9807     }
     9808     printf("Column breakdown:\n");
     9809     int k;
     9810     for (k = 0; k < static_cast<int> (sizeof(cType) / sizeof(int)); k++) {
     9811          printf("%d of type %s ", cType[k], cName[k].c_str());
     9812          if (((k + 1) % 3) == 0)
     9813               printf("\n");
     9814     }
     9815     if ((k % 3) != 0)
     9816          printf("\n");
     9817     printf("Row breakdown:\n");
     9818     for (k = 0; k < static_cast<int> (sizeof(rType) / sizeof(int)); k++) {
     9819          printf("%d of type %s ", rType[k], rName[k].c_str());
     9820          if (((k + 1) % 3) == 0)
     9821               printf("\n");
     9822     }
     9823     if ((k % 3) != 0)
     9824          printf("\n");
     9825     //#define SYM
     9826#ifndef SYM
     9827     if (model->logLevel() < 2)
     9828          return ;
     9829#endif
     9830     int kMax = model->logLevel() > 3 ? 1000000 : 10;
     9831     k = 0;
     9832     for (iRow = 1; iRow <= numberRows; iRow++) {
     9833          if (number[iRow]) {
     9834               k++;
     9835               printf("%d columns have %d entries\n", number[iRow], iRow);
     9836               if (k == kMax)
    96169837                    break;
    9617             }
    9618         }
    9619         if (k > kk) {
    9620             printf("\n    .........\n\n");
    9621             iRow = k;
    9622             k = 0;
    9623             for (; iRow < numberRows; iRow++) {
    9624                 if (number[iRow]) {
     9838          }
     9839     }
     9840     if (k < numberRows) {
     9841          int kk = k;
     9842          k = 0;
     9843          for (iRow = numberRows; iRow >= 1; iRow--) {
     9844               if (number[iRow]) {
    96259845                    k++;
    9626                     printf("%d columns have %d entries\n", number[iRow], iRow);
    96279846                    if (k == kMax)
    9628                         break;
    9629                 }
    9630             }
    9631         }
    9632     }
    9633     delete [] number;
    9634     printf("\n\n");
    9635     // get row copy
    9636     CoinPackedMatrix rowCopy = *matrix;
    9637     rowCopy.reverseOrdering();
    9638     //const int * column = rowCopy.getIndices();
    9639     const int * rowLength = rowCopy.getVectorLengths();
    9640     //const CoinBigIndex * rowStart = rowCopy.getVectorStarts();
    9641     //const double * element = rowCopy.getElements();
    9642     number = new int[numberColumns+1];
    9643     memset(number, 0, (numberColumns + 1)*sizeof(int));
    9644     for (iRow = 0; iRow < numberRows; iRow++) {
    9645         int length = rowLength[iRow];
    9646         number[length]++;
    9647     }
    9648     if (number[0])
    9649         printf("** %d rows have no entries\n", number[0]);
    9650     k = 0;
    9651     for (iColumn = 1; iColumn <= numberColumns; iColumn++) {
    9652         if (number[iColumn]) {
    9653             k++;
    9654             printf("%d rows have %d entries\n", number[iColumn], iColumn);
    9655             if (k == kMax)
    9656                 break;
    9657         }
    9658     }
    9659     if (k < numberColumns) {
    9660         int kk = k;
    9661         k = 0;
    9662         for (iColumn = numberColumns; iColumn >= 1; iColumn--) {
    9663             if (number[iColumn]) {
    9664                 k++;
    9665                 if (k == kMax)
     9847                         break;
     9848               }
     9849          }
     9850          if (k > kk) {
     9851               printf("\n    .........\n\n");
     9852               iRow = k;
     9853               k = 0;
     9854               for (; iRow < numberRows; iRow++) {
     9855                    if (number[iRow]) {
     9856                         k++;
     9857                         printf("%d columns have %d entries\n", number[iRow], iRow);
     9858                         if (k == kMax)
     9859                              break;
     9860                    }
     9861               }
     9862          }
     9863     }
     9864     delete [] number;
     9865     printf("\n\n");
     9866     if (model->logLevel() == 63
     9867#ifdef SYM
     9868               || true
     9869#endif
     9870        ) {
     9871          // get column copy
     9872          CoinPackedMatrix columnCopy = *matrix;
     9873          const int * columnLength = columnCopy.getVectorLengths();
     9874          number = new int[numberRows+1];
     9875          memset(number, 0, (numberRows + 1)*sizeof(int));
     9876          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     9877               int length = columnLength[iColumn];
     9878               number[length]++;
     9879          }
     9880          k = 0;
     9881          for (iRow = 1; iRow <= numberRows; iRow++) {
     9882               if (number[iRow]) {
     9883                    k++;
     9884               }
     9885          }
     9886          int * row = columnCopy.getMutableIndices();
     9887          const CoinBigIndex * columnStart = columnCopy.getVectorStarts();
     9888          double * element = columnCopy.getMutableElements();
     9889          int * order = new int[numberColumns];
     9890          int * other = new int[numberColumns];
     9891          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     9892               int length = columnLength[iColumn];
     9893               order[iColumn] = iColumn;
     9894               other[iColumn] = length;
     9895               CoinBigIndex start = columnStart[iColumn];
     9896               CoinSort_2(row + start, row + start + length, element + start);
     9897          }
     9898          CoinSort_2(other, other + numberColumns, order);
     9899          int jColumn = number[0] + number[1];
     9900          for (iRow = 2; iRow <= numberRows; iRow++) {
     9901               if (number[iRow]) {
     9902                    printf("XX %d columns have %d entries\n", number[iRow], iRow);
     9903                    int kColumn = jColumn + number[iRow];
     9904                    sortOnOther(row, columnStart,
     9905                                order + jColumn, other, number[iRow], iRow, 0);
     9906                    // Now print etc
     9907                    if (iRow < 500000) {
     9908                         for (int lColumn = jColumn; lColumn < kColumn; lColumn++) {
     9909                              iColumn = order[lColumn];
     9910                              CoinBigIndex start = columnStart[iColumn];
     9911                              if (model->logLevel() == 63) {
     9912                                   printf("column %d %g <= ", iColumn, columnLower[iColumn]);
     9913                                   for (CoinBigIndex i = start; i < start + iRow; i++)
     9914                                        printf("( %d, %g) ", row[i], element[i]);
     9915                                   printf("<= %g\n", columnUpper[iColumn]);
     9916                              }
     9917                         }
     9918                    }
     9919                    jColumn = kColumn;
     9920               }
     9921          }
     9922          delete [] order;
     9923          delete [] other;
     9924          delete [] number;
     9925     }
     9926     // get row copy
     9927     CoinPackedMatrix rowCopy = *matrix;
     9928     rowCopy.reverseOrdering();
     9929     const int * rowLength = rowCopy.getVectorLengths();
     9930     number = new int[numberColumns+1];
     9931     memset(number, 0, (numberColumns + 1)*sizeof(int));
     9932     if (model->logLevel() > 3) {
     9933       // get column copy
     9934       CoinPackedMatrix columnCopy = *matrix;
     9935       const int * columnLength = columnCopy.getVectorLengths();
     9936       const int * row = columnCopy.getIndices();
     9937       const CoinBigIndex * columnStart = columnCopy.getVectorStarts();
     9938       const double * element = columnCopy.getElements();
     9939       const double * elementByRow = rowCopy.getElements();
     9940       const int * rowStart = rowCopy.getVectorStarts();
     9941       const int * column = rowCopy.getIndices();
     9942       int nPossibleZeroCost=0;
     9943       int nPossibleNonzeroCost=0;
     9944       for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     9945         int length = columnLength[iColumn];
     9946         if (columnLower[iColumn]<-1.0e30&&columnUpper[iColumn]>1.0e30) {
     9947           if (length==1) {
     9948             printf("Singleton free %d - cost %g\n",iColumn,objective[iColumn]);
     9949           } else if (length==2) {
     9950             int iRow0=row[columnStart[iColumn]];
     9951             int iRow1=row[columnStart[iColumn]+1];
     9952             double element0=element[columnStart[iColumn]];
     9953             double element1=element[columnStart[iColumn]+1];
     9954             int n0=rowLength[iRow0];
     9955             int n1=rowLength[iRow1];
     9956             printf("Doubleton free %d - cost %g - %g in %srow with %d entries and %g in %srow with %d entries\n",
     9957                    iColumn,objective[iColumn],element0,(rowLower[iRow0]==rowUpper[iRow0]) ? "==" : "",n0,
     9958                    element1,(rowLower[iRow1]==rowUpper[iRow1]) ? "==" : "",n1);
     9959
     9960           }
     9961         }
     9962         if (length==1) {
     9963           int iRow=row[columnStart[iColumn]];
     9964           double value=COIN_DBL_MAX;
     9965           for (int i=rowStart[iRow];i<rowStart[iRow]+rowLength[iRow];i++) {
     9966             int jColumn=column[i];
     9967             if (jColumn!=iColumn) {
     9968               if (value!=elementByRow[i]) {
     9969                 if (value==COIN_DBL_MAX) {
     9970                   value=elementByRow[i];
     9971                 } else {
     9972                   value = -COIN_DBL_MAX;
     9973                   break;
     9974                 }
     9975               }
     9976             }
     9977           }
     9978           if (!objective[iColumn]) {
     9979             if (model->logLevel() > 4)
     9980             printf("Singleton %d with no objective in row with %d elements - rhs %g,%g\n",iColumn,rowLength[iRow],rowLower[iRow],rowUpper[iRow]);
     9981             nPossibleZeroCost++;
     9982           } else if (value!=-COIN_DBL_MAX) {
     9983             if (model->logLevel() > 4)
     9984               printf("Singleton %d (%s) with objective in row %d (%s) with %d equal elements - rhs %g,%g\n",iColumn,model->getColumnName(iColumn).c_str(),
     9985                      iRow,model->getRowName(iRow).c_str(),
     9986                      rowLength[iRow],rowLower[iRow],rowUpper[iRow]);
     9987             nPossibleNonzeroCost++;
     9988           }
     9989         }
     9990       }
     9991       if (nPossibleZeroCost||nPossibleNonzeroCost)
     9992         printf("%d singletons with zero cost, %d with valid cost\n",
     9993                nPossibleZeroCost,nPossibleNonzeroCost);
     9994       // look for DW
     9995       int * blockStart = new int [2*(numberRows+numberColumns)+1+numberRows];
     9996       int * columnBlock = blockStart+numberRows;
     9997       int * nextColumn = columnBlock+numberColumns;
     9998       int * blockCount = nextColumn+numberColumns;
     9999       int * blockEls = blockCount+numberRows+1;
     10000       int direction[2]={-1,1};
     10001       int bestBreak=-1;
     10002       double bestValue=0.0;
     10003       int iPass=0;
     10004       int halfway=(numberRows+1)/2;
     10005       int firstMaster=-1;
     10006       int lastMaster=-2;
     10007       while (iPass<2) {
     10008         int increment=direction[iPass];
     10009         int start= increment>0 ? 0 : numberRows-1;
     10010         int stop=increment>0 ? numberRows : -1;
     10011         int numberBlocks=0;
     10012         int thisBestBreak=-1;
     10013         double thisBestValue=COIN_DBL_MAX;
     10014         int numberRowsDone=0;
     10015         int numberMarkedColumns=0;
     10016         int maximumBlockSize=0;
     10017         for (int i=0;i<numberRows+2*numberColumns;i++)
     10018           blockStart[i]=-1;
     10019         for (int i=0;i<numberRows+1;i++)
     10020           blockCount[i]=0;
     10021         for (int iRow=start;iRow!=stop;iRow+=increment) {
     10022           int iBlock = -1;
     10023           for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
     10024             int iColumn=column[j];
     10025             int whichColumnBlock=columnBlock[iColumn];
     10026             if (whichColumnBlock>=0) {
     10027               // column marked
     10028               if (iBlock<0) {
     10029                 // put row in that block
     10030                 iBlock=whichColumnBlock;
     10031               } else if (iBlock!=whichColumnBlock) {
     10032                 // merge
     10033                 blockCount[iBlock]+=blockCount[whichColumnBlock];
     10034                 blockCount[whichColumnBlock]=0;
     10035                 int jColumn=blockStart[whichColumnBlock];
     10036                 while (jColumn>=0) {
     10037                   columnBlock[jColumn]=iBlock;
     10038                   iColumn=jColumn;
     10039                   jColumn=nextColumn[jColumn];
     10040                 }
     10041                 nextColumn[iColumn]=blockStart[iBlock];
     10042                 blockStart[iBlock]=blockStart[whichColumnBlock];
     10043                 blockStart[whichColumnBlock]=-1;
     10044               }
     10045             }
     10046           }
     10047           int n=numberMarkedColumns;
     10048           if (iBlock<0) {
     10049             //new block
     10050             if (rowLength[iRow]) {
     10051               numberBlocks++;
     10052               iBlock=numberBlocks;
     10053               int jColumn=column[rowStart[iRow]];
     10054               columnBlock[jColumn]=iBlock;
     10055               blockStart[iBlock]=jColumn;
     10056               numberMarkedColumns++;
     10057               for (CoinBigIndex j=rowStart[iRow]+1;j<rowStart[iRow]+rowLength[iRow];j++) {
     10058                 int iColumn=column[j];
     10059                 columnBlock[iColumn]=iBlock;
     10060                 numberMarkedColumns++;
     10061                 nextColumn[jColumn]=iColumn;
     10062                 jColumn=iColumn;
     10063               }
     10064               blockCount[iBlock]=numberMarkedColumns-n;
     10065             } else {
     10066               // empty
     10067               iBlock=numberRows;
     10068             }
     10069           } else {
     10070             // put in existing block
     10071             int jColumn=blockStart[iBlock];
     10072             for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
     10073               int iColumn=column[j];
     10074               assert (columnBlock[iColumn]<0||columnBlock[iColumn]==iBlock);
     10075               if (columnBlock[iColumn]<0) {
     10076                 columnBlock[iColumn]=iBlock;
     10077                 numberMarkedColumns++;
     10078                 nextColumn[iColumn]=jColumn;
     10079                 jColumn=iColumn;
     10080               }
     10081             }
     10082             blockStart[iBlock]=jColumn;
     10083             blockCount[iBlock]+=numberMarkedColumns-n;
     10084           }
     10085           maximumBlockSize=CoinMax(maximumBlockSize,blockCount[iBlock]);
     10086           numberRowsDone++;
     10087           if (thisBestValue*numberRowsDone > maximumBlockSize&&numberRowsDone>halfway) {
     10088             thisBestBreak=iRow;
     10089             thisBestValue=static_cast<double>(maximumBlockSize)/
     10090               static_cast<double>(numberRowsDone);
     10091           }
     10092         }
     10093         if (thisBestBreak==stop)
     10094           thisBestValue=COIN_DBL_MAX;
     10095         iPass++;
     10096         if (iPass==1) {
     10097           bestBreak=thisBestBreak;
     10098           bestValue=thisBestValue;
     10099         } else {
     10100           if (bestValue<thisBestValue) {
     10101             firstMaster=0;
     10102             lastMaster=bestBreak;
     10103           } else {
     10104             firstMaster=thisBestBreak; // ? +1
     10105             lastMaster=numberRows;
     10106           }
     10107         }
     10108       }
     10109       if (firstMaster<lastMaster) {
     10110         printf("%d master rows %d <= < %d\n",lastMaster-firstMaster,
     10111                firstMaster,lastMaster);
     10112         for (int i=0;i<numberRows+2*numberColumns;i++)
     10113           blockStart[i]=-1;
     10114         for (int i=firstMaster;i<lastMaster;i++)
     10115           blockStart[i]=-2;
     10116         int firstRow=0;
     10117         int numberBlocks=-1;
     10118         while (true) {
     10119           for (;firstRow<numberRows;firstRow++) {
     10120             if (blockStart[firstRow]==-1)
     10121               break;
     10122           }
     10123           if (firstRow==numberRows)
     10124             break;
     10125           int nRows=0;
     10126           numberBlocks++;
     10127           int numberStack=1;
     10128           blockCount[0] = firstRow;
     10129           while (numberStack) {
     10130             int iRow=blockCount[--numberStack];
     10131             for (CoinBigIndex j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
     10132               int iColumn=column[j];
     10133               int iBlock=columnBlock[iColumn];
     10134               if (iBlock<0) {
     10135                 columnBlock[iColumn]=numberBlocks;
     10136                 for (CoinBigIndex k=columnStart[iColumn];
     10137                      k<columnStart[iColumn]+columnLength[iColumn];k++) {
     10138                   int jRow=row[k];
     10139                   int rowBlock=blockStart[jRow];
     10140                   if (rowBlock==-1) {
     10141                     nRows++;
     10142                     blockStart[jRow]=numberBlocks;
     10143                     blockCount[numberStack++]=jRow;
     10144                   }
     10145                 }
     10146               }
     10147             }
     10148           }
     10149           if (!nRows) {
     10150             // empty!!
     10151             numberBlocks--;
     10152           }
     10153           firstRow++;
     10154         }
     10155         // adjust
     10156         numberBlocks++;
     10157         for (int i=0;i<numberBlocks;i++) {
     10158           blockCount[i]=0;
     10159           nextColumn[i]=0;
     10160         }
     10161         int numberEmpty=0;
     10162         int numberMaster=0;
     10163         memset(blockEls,0,numberBlocks*sizeof(int));
     10164         for (int iRow = 0; iRow < numberRows; iRow++) {
     10165           int iBlock=blockStart[iRow];
     10166           if (iBlock>=0) {
     10167             blockCount[iBlock]++;
     10168             blockEls[iBlock]+=rowLength[iRow];
     10169           } else {
     10170             if (iBlock==-2)
     10171               numberMaster++;
     10172             else
     10173               numberEmpty++;
     10174           }
     10175         }
     10176         int numberEmptyColumns=0;
     10177         int numberMasterColumns=0;
     10178         for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     10179           int iBlock=columnBlock[iColumn];
     10180           if (iBlock>=0) {
     10181             nextColumn[iBlock]++;
     10182           } else {
     10183             if (columnLength[iColumn])
     10184               numberMasterColumns++;
     10185             else
     10186               numberEmptyColumns++;
     10187           }
     10188         }
     10189         int largestRows=0;
     10190         int largestColumns=0;
     10191         for (int i=0;i<numberBlocks;i++) {
     10192           if (blockCount[i]+nextColumn[i]>largestRows+largestColumns) {
     10193             largestRows=blockCount[i];
     10194             largestColumns=nextColumn[i];
     10195           }
     10196         }
     10197         bool useful=true;
     10198         if (numberMaster>halfway||largestRows*3>numberRows)
     10199           useful=false;
     10200         printf("%s %d blocks (largest %d,%d), %d master rows (%d empty) out of %d, %d master columns (%d empty) out of %d\n",
     10201                useful ? "**Useful" : "NoGood",
     10202                numberBlocks,largestRows,largestColumns,numberMaster,numberEmpty,numberRows,
     10203                numberMasterColumns,numberEmptyColumns,numberColumns);
     10204         FILE * fp=NULL;
     10205         bool justIntegers=true;
     10206         bool oneFile=true;
     10207         int logLevel = model->logLevel();
     10208         if (logLevel>19) {
     10209           logLevel-=2;
     10210           oneFile=true;
     10211           fp = fopen("fake.bnd","w");
     10212         }
     10213         if (logLevel==19)
     10214           justIntegers=false;
     10215         for (int i=0;i<numberBlocks;i++)
     10216           printf("Block %d has %d rows and %d columns (%d elements)\n",
     10217                  i,blockCount[i],nextColumn[i],blockEls[i]);
     10218         if (logLevel >= 17 && logLevel <= 21) {
     10219           int * whichRows=new int[numberRows+numberColumns];
     10220           int * whichColumns=whichRows+numberRows;
     10221           char name[20];
     10222           for (int iBlock=0;iBlock<numberBlocks;iBlock++) {
     10223             sprintf(name,"block%d.mps",iBlock);
     10224             int nRows=0;
     10225             for (int iRow=0;iRow<numberRows;iRow++) {
     10226               if (blockStart[iRow]==iBlock)
     10227                 whichRows[nRows++]=iRow;
     10228             }
     10229             int nColumns=0;
     10230             for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     10231               if (columnBlock[iColumn]==iBlock)
     10232                 whichColumns[nColumns++]=iColumn;
     10233             }
     10234             ClpSimplex subset(model,nRows,whichRows,nColumns,whichColumns);
     10235             for (int jRow=0;jRow<nRows;jRow++) {
     10236               int iRow = whichRows[jRow];
     10237               std::string name = model->getRowName(iRow);
     10238               subset.setRowName(jRow,name);
     10239             }
     10240             int nInteger=0;
     10241             for (int jColumn=0;jColumn<nColumns;jColumn++) {
     10242               int iColumn = whichColumns[jColumn];
     10243               if (model->isInteger(iColumn)) {
     10244                 subset.setInteger(jColumn);
     10245                 nInteger++;
     10246               }
     10247               std::string name = model->getColumnName(iColumn);
     10248               subset.setColumnName(jColumn,name);
     10249             }
     10250             if (logLevel == 17) {
     10251               subset.writeMps(name,0,1);
     10252             } else if (nInteger) {
     10253               OsiClpSolverInterface subset2(&subset);
     10254               CbcModel smallModel(subset2);
     10255               smallModel.branchAndBound();
     10256               const double * solution = smallModel.bestSolution();
     10257               if (solution) {
     10258                 if (!oneFile) {
     10259                   sprintf(name,"block%d.bnd",iBlock);
     10260                   fp = fopen(name,"w");
     10261                   assert (fp);
     10262                 }
     10263                 fprintf(fp,"BBB objective %g for block %d\n",
     10264                         smallModel.getObjValue(),iBlock);
     10265                 for (int jColumn=0;jColumn<nColumns;jColumn++) {
     10266                   if (subset.isInteger(jColumn)||
     10267                       !justIntegers)
     10268                     fprintf(fp," FX BOUND1    %.8s  %g\n",
     10269                             subset.getColumnName(jColumn).c_str(),
     10270                             solution[jColumn]);
     10271                 }
     10272                 if (!oneFile)
     10273                   fclose(fp);
     10274               } else {
     10275                 printf("***** Problem is infeasible\n");
     10276                 abort();
     10277               }
     10278             }
     10279           }
     10280           if (oneFile)
     10281             fclose(fp);
     10282           delete [] whichRows;
     10283         }
     10284       }
     10285       delete [] blockStart;
     10286     }
     10287     for (iRow = 0; iRow < numberRows; iRow++) {
     10288          int length = rowLength[iRow];
     10289          number[length]++;
     10290     }
     10291     if (number[0])
     10292          printf("** %d rows have no entries\n", number[0]);
     10293     k = 0;
     10294     for (iColumn = 1; iColumn <= numberColumns; iColumn++) {
     10295          if (number[iColumn]) {
     10296               k++;
     10297               printf("%d rows have %d entries\n", number[iColumn], iColumn);
     10298               if (k == kMax)
    966610299                    break;
    9667             }
    9668         }
    9669         if (k > kk) {
    9670             printf("\n    .........\n\n");
    9671             iColumn = k;
    9672             k = 0;
    9673             for (; iColumn < numberColumns; iColumn++) {
    9674                 if (number[iColumn]) {
     10300          }
     10301     }
     10302     if (k < numberColumns) {
     10303          int kk = k;
     10304          k = 0;
     10305          for (iColumn = numberColumns; iColumn >= 1; iColumn--) {
     10306               if (number[iColumn]) {
    967510307                    k++;
    9676                     printf("%d rows have %d entries\n", number[iColumn], iColumn);
    967710308                    if (k == kMax)
    9678                         break;
    9679                 }
    9680             }
    9681         }
    9682     }
    9683     delete [] number;
    9684     // Now do breakdown of ranges
    9685     breakdown("Elements", numberElements, elementByColumn);
    9686     breakdown("RowLower", numberRows, rowLower);
    9687     breakdown("RowUpper", numberRows, rowUpper);
    9688     breakdown("ColumnLower", numberColumns, columnLower);
    9689     breakdown("ColumnUpper", numberColumns, columnUpper);
    9690     breakdown("Objective", numberColumns, objective);
     10309                         break;
     10310               }
     10311          }
     10312          if (k > kk) {
     10313               printf("\n    .........\n\n");
     10314               iColumn = k;
     10315               k = 0;
     10316               for (; iColumn < numberColumns; iColumn++) {
     10317                    if (number[iColumn]) {
     10318                         k++;
     10319                         printf("%d rows have %d entries\n", number[iColumn], iColumn);
     10320                         if (k == kMax)
     10321                              break;
     10322                    }
     10323               }
     10324          }
     10325     }
     10326     if (model->logLevel() == 63
     10327#ifdef SYM
     10328               || true
     10329#endif
     10330        ) {
     10331          int * column = rowCopy.getMutableIndices();
     10332          const CoinBigIndex * rowStart = rowCopy.getVectorStarts();
     10333          double * element = rowCopy.getMutableElements();
     10334          int * order = new int[numberRows];
     10335          int * other = new int[numberRows];
     10336          for (iRow = 0; iRow < numberRows; iRow++) {
     10337               int length = rowLength[iRow];
     10338               order[iRow] = iRow;
     10339               other[iRow] = length;
     10340               CoinBigIndex start = rowStart[iRow];
     10341               CoinSort_2(column + start, column + start + length, element + start);
     10342          }
     10343          CoinSort_2(other, other + numberRows, order);
     10344          int jRow = number[0] + number[1];
     10345          double * weight = new double[numberRows];
     10346          double * randomColumn = new double[numberColumns+1];
     10347          double * randomRow = new double [numberRows+1];
     10348          int * sortRow = new int [numberRows];
     10349          int * possibleRow = new int [numberRows];
     10350          int * backRow = new int [numberRows];
     10351          int * stackRow = new int [numberRows];
     10352          int * sortColumn = new int [numberColumns];
     10353          int * possibleColumn = new int [numberColumns];
     10354          int * backColumn = new int [numberColumns];
     10355          int * backColumn2 = new int [numberColumns];
     10356          int * mapRow = new int [numberRows];
     10357          int * mapColumn = new int [numberColumns];
     10358          int * stackColumn = new int [numberColumns];
     10359          double randomLower = CoinDrand48();
     10360          double randomUpper = CoinDrand48();
     10361          double randomInteger = CoinDrand48();
     10362          int * startAdd = new int[numberRows+1];
     10363          int * columnAdd = new int [2*numberElements];
     10364          double * elementAdd = new double[2*numberElements];
     10365          int nAddRows = 0;
     10366          startAdd[0] = 0;
     10367          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     10368               randomColumn[iColumn] = CoinDrand48();
     10369               backColumn2[iColumn] = -1;
     10370          }
     10371          for (iColumn = 2; iColumn <= numberColumns; iColumn++) {
     10372               if (number[iColumn]) {
     10373                    printf("XX %d rows have %d entries\n", number[iColumn], iColumn);
     10374                    int kRow = jRow + number[iColumn];
     10375                    sortOnOther(column, rowStart,
     10376                                order + jRow, other, number[iColumn], iColumn, 0);
     10377                    // Now print etc
     10378                    if (iColumn < 500000) {
     10379                         int nLook = 0;
     10380                         for (int lRow = jRow; lRow < kRow; lRow++) {
     10381                              iRow = order[lRow];
     10382                              CoinBigIndex start = rowStart[iRow];
     10383                              if (model->logLevel() == 63) {
     10384                                   printf("row %d %g <= ", iRow, rowLower[iRow]);
     10385                                   for (CoinBigIndex i = start; i < start + iColumn; i++)
     10386                                        printf("( %d, %g) ", column[i], element[i]);
     10387                                   printf("<= %g\n", rowUpper[iRow]);
     10388                              }
     10389                              int first = column[start];
     10390                              double sum = 0.0;
     10391                              for (CoinBigIndex i = start; i < start + iColumn; i++) {
     10392                                   int jColumn = column[i];
     10393                                   double value = element[i];
     10394                                   jColumn -= first;
     10395                                   assert (jColumn >= 0);
     10396                                   sum += value * randomColumn[jColumn];
     10397                              }
     10398                              if (rowLower[iRow] > -1.0e30 && rowLower[iRow])
     10399                                   sum += rowLower[iRow] * randomLower;
     10400                              else if (!rowLower[iRow])
     10401                                   sum += 1.234567e-7 * randomLower;
     10402                              if (rowUpper[iRow] < 1.0e30 && rowUpper[iRow])
     10403                                   sum += rowUpper[iRow] * randomUpper;
     10404                              else if (!rowUpper[iRow])
     10405                                   sum += 1.234567e-7 * randomUpper;
     10406                              sortRow[nLook] = iRow;
     10407                              randomRow[nLook++] = sum;
     10408                              // best way is to number unique elements and bounds and use
     10409                              if (fabs(sum) > 1.0e4)
     10410                                   sum *= 1.0e-6;
     10411                              weight[iRow] = sum;
     10412                         }
     10413                         assert (nLook <= numberRows);
     10414                         CoinSort_2(randomRow, randomRow + nLook, sortRow);
     10415                         randomRow[nLook] = COIN_DBL_MAX;
     10416                         double last = -COIN_DBL_MAX;
     10417                         int iLast = -1;
     10418                         for (int iLook = 0; iLook < nLook + 1; iLook++) {
     10419                              if (randomRow[iLook] > last) {
     10420                                   if (iLast >= 0) {
     10421                                        int n = iLook - iLast;
     10422                                        if (n > 1) {
     10423                                             //printf("%d rows possible?\n",n);
     10424                                        }
     10425                                   }
     10426                                   iLast = iLook;
     10427                                   last = randomRow[iLook];
     10428                              }
     10429                         }
     10430                    }
     10431                    jRow = kRow;
     10432               }
     10433          }
     10434          CoinPackedMatrix columnCopy = *matrix;
     10435          const int * columnLength = columnCopy.getVectorLengths();
     10436          const int * row = columnCopy.getIndices();
     10437          const CoinBigIndex * columnStart = columnCopy.getVectorStarts();
     10438          const double * elementByColumn = columnCopy.getElements();
     10439          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     10440               int length = columnLength[iColumn];
     10441               CoinBigIndex start = columnStart[iColumn];
     10442               double sum = objective[iColumn];
     10443               if (columnLower[iColumn] > -1.0e30 && columnLower[iColumn])
     10444                    sum += columnLower[iColumn] * randomLower;
     10445               else if (!columnLower[iColumn])
     10446                    sum += 1.234567e-7 * randomLower;
     10447               if (columnUpper[iColumn] < 1.0e30 && columnUpper[iColumn])
     10448                    sum += columnUpper[iColumn] * randomUpper;
     10449               else if (!columnUpper[iColumn])
     10450                    sum += 1.234567e-7 * randomUpper;
     10451               if (model->isInteger(iColumn))
     10452                    sum += 9.87654321e-6 * randomInteger;
     10453               for (CoinBigIndex i = start; i < start + length; i++) {
     10454                    int iRow = row[i];
     10455                    sum += elementByColumn[i] * weight[iRow];
     10456               }
     10457               sortColumn[iColumn] = iColumn;
     10458               randomColumn[iColumn] = sum;
     10459          }
     10460          {
     10461               CoinSort_2(randomColumn, randomColumn + numberColumns, sortColumn);
     10462               for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     10463                    int i = sortColumn[iColumn];
     10464                    backColumn[i] = iColumn;
     10465               }
     10466               randomColumn[numberColumns] = COIN_DBL_MAX;
     10467               double last = -COIN_DBL_MAX;
     10468               int iLast = -1;
     10469               for (int iLook = 0; iLook < numberColumns + 1; iLook++) {
     10470                    if (randomColumn[iLook] > last) {
     10471                         if (iLast >= 0) {
     10472                              int n = iLook - iLast;
     10473                              if (n > 1) {
     10474                                   //printf("%d columns possible?\n",n);
     10475                              }
     10476                              for (int i = iLast; i < iLook; i++) {
     10477                                   possibleColumn[sortColumn[i]] = n;
     10478                              }
     10479                         }
     10480                         iLast = iLook;
     10481                         last = randomColumn[iLook];
     10482                    }
     10483               }
     10484               for (iRow = 0; iRow < numberRows; iRow++) {
     10485                    CoinBigIndex start = rowStart[iRow];
     10486                    double sum = 0.0;
     10487                    int length = rowLength[iRow];
     10488                    for (CoinBigIndex i = start; i < start + length; i++) {
     10489                         int jColumn = column[i];
     10490                         double value = element[i];
     10491                         jColumn = backColumn[jColumn];
     10492                         sum += value * randomColumn[jColumn];
     10493                         //if (iColumn==23089||iRow==23729)
     10494                         //printf("row %d cola %d colb %d value %g rand %g sum %g\n",
     10495                         //   iRow,jColumn,column[i],value,randomColumn[jColumn],sum);
     10496                    }
     10497                    sortRow[iRow] = iRow;
     10498                    randomRow[iRow] = weight[iRow];
     10499                    randomRow[iRow] = sum;
     10500               }
     10501               CoinSort_2(randomRow, randomRow + numberRows, sortRow);
     10502               for (iRow = 0; iRow < numberRows; iRow++) {
     10503                    int i = sortRow[iRow];
     10504                    backRow[i] = iRow;
     10505               }
     10506               randomRow[numberRows] = COIN_DBL_MAX;
     10507               last = -COIN_DBL_MAX;
     10508               iLast = -1;
     10509               // Do backward indices from order
     10510               for (iRow = 0; iRow < numberRows; iRow++) {
     10511                    other[order[iRow]] = iRow;
     10512               }
     10513               for (int iLook = 0; iLook < numberRows + 1; iLook++) {
     10514                    if (randomRow[iLook] > last) {
     10515                         if (iLast >= 0) {
     10516                              int n = iLook - iLast;
     10517                              if (n > 1) {
     10518                                   //printf("%d rows possible?\n",n);
     10519                                   // Within group sort as for original "order"
     10520                                   for (int i = iLast; i < iLook; i++) {
     10521                                        int jRow = sortRow[i];
     10522                                        order[i] = other[jRow];
     10523                                   }
     10524                                   CoinSort_2(order + iLast, order + iLook, sortRow + iLast);
     10525                              }
     10526                              for (int i = iLast; i < iLook; i++) {
     10527                                   possibleRow[sortRow[i]] = n;
     10528                              }
     10529                         }
     10530                         iLast = iLook;
     10531                         last = randomRow[iLook];
     10532                    }
     10533               }
     10534               // Temp out
     10535               for (int iLook = 0; iLook < numberRows - 1000000; iLook++) {
     10536                    iRow = sortRow[iLook];
     10537                    CoinBigIndex start = rowStart[iRow];
     10538                    int length = rowLength[iRow];
     10539                    int numberPossible = possibleRow[iRow];
     10540                    for (CoinBigIndex i = start; i < start + length; i++) {
     10541                         int jColumn = column[i];
     10542                         if (possibleColumn[jColumn] != numberPossible)
     10543                              numberPossible = -1;
     10544                    }
     10545                    int n = numberPossible;
     10546                    if (numberPossible > 1) {
     10547                         //printf("pppppossible %d\n",numberPossible);
     10548                         for (int jLook = iLook + 1; jLook < iLook + numberPossible; jLook++) {
     10549                              int jRow = sortRow[jLook];
     10550                              CoinBigIndex start2 = rowStart[jRow];
     10551                              assert (numberPossible == possibleRow[jRow]);
     10552                              assert(length == rowLength[jRow]);
     10553                              for (CoinBigIndex i = start2; i < start2 + length; i++) {
     10554                                   int jColumn = column[i];
     10555                                   if (possibleColumn[jColumn] != numberPossible)
     10556                                        numberPossible = -1;
     10557                              }
     10558                         }
     10559                         if (numberPossible < 2) {
     10560                              // switch off
     10561                              for (int jLook = iLook; jLook < iLook + n; jLook++)
     10562                                   possibleRow[sortRow[jLook]] = -1;
     10563                         }
     10564                         // skip rest
     10565                         iLook += n - 1;
     10566                    } else {
     10567                         possibleRow[iRow] = -1;
     10568                    }
     10569               }
     10570               for (int iLook = 0; iLook < numberRows; iLook++) {
     10571                    iRow = sortRow[iLook];
     10572                    int numberPossible = possibleRow[iRow];
     10573                    // Only if any integers
     10574                    int numberIntegers = 0;
     10575                    CoinBigIndex start = rowStart[iRow];
     10576                    int length = rowLength[iRow];
     10577                    for (CoinBigIndex i = start; i < start + length; i++) {
     10578                         int jColumn = column[i];
     10579                         if (model->isInteger(jColumn))
     10580                              numberIntegers++;
     10581                    }
     10582                    if (numberPossible > 1 && !numberIntegers) {
     10583                         //printf("possible %d - but no integers\n",numberPossible);
     10584                    }
     10585                    if (numberPossible > 1 && (numberIntegers || false)) {
     10586                         //
     10587                         printf("possible %d - %d integers\n", numberPossible, numberIntegers);
     10588                         int lastLook = iLook;
     10589                         int nMapRow = -1;
     10590                         for (int jLook = iLook + 1; jLook < iLook + numberPossible; jLook++) {
     10591                              // stop if too many failures
     10592                              if (jLook > iLook + 10 && nMapRow < 0)
     10593                                   break;
     10594                              // Create identity mapping
     10595                              int i;
     10596                              for (i = 0; i < numberRows; i++)
     10597                                   mapRow[i] = i;
     10598                              for (i = 0; i < numberColumns; i++)
     10599                                   mapColumn[i] = i;
     10600                              int offset = jLook - iLook;
     10601                              int nStackC = 0;
     10602                              // build up row and column mapping
     10603                              int nStackR = 1;
     10604                              stackRow[0] = iLook;
     10605                              bool good = true;
     10606                              while (nStackR) {
     10607                                   nStackR--;
     10608                                   int look1 = stackRow[nStackR];
     10609                                   int look2 = look1 + offset;
     10610                                   assert (randomRow[look1] == randomRow[look2]);
     10611                                   int row1 = sortRow[look1];
     10612                                   int row2 = sortRow[look2];
     10613                                   assert (mapRow[row1] == row1);
     10614                                   assert (mapRow[row2] == row2);
     10615                                   mapRow[row1] = row2;
     10616                                   mapRow[row2] = row1;
     10617                                   CoinBigIndex start1 = rowStart[row1];
     10618                                   CoinBigIndex offset2 = rowStart[row2] - start1;
     10619                                   int length = rowLength[row1];
     10620                                   assert( length == rowLength[row2]);
     10621                                   for (CoinBigIndex i = start1; i < start1 + length; i++) {
     10622                                        int jColumn1 = column[i];
     10623                                        int jColumn2 = column[i+offset2];
     10624                                        if (randomColumn[backColumn[jColumn1]] !=
     10625                                                  randomColumn[backColumn[jColumn2]]) {
     10626                                             good = false;
     10627                                             break;
     10628                                        }
     10629                                        if (mapColumn[jColumn1] == jColumn1) {
     10630                                             // not touched
     10631                                             assert (mapColumn[jColumn2] == jColumn2);
     10632                                             if (jColumn1 != jColumn2) {
     10633                                                  // Put on stack
     10634                                                  mapColumn[jColumn1] = jColumn2;
     10635                                                  mapColumn[jColumn2] = jColumn1;
     10636                                                  stackColumn[nStackC++] = jColumn1;
     10637                                             }
     10638                                        } else {
     10639                                             if (mapColumn[jColumn1] != jColumn2 ||
     10640                                                       mapColumn[jColumn2] != jColumn1) {
     10641                                                  // bad
     10642                                                  good = false;
     10643                                                  printf("bad col\n");
     10644                                                  break;
     10645                                             }
     10646                                        }
     10647                                   }
     10648                                   if (!good)
     10649                                        break;
     10650                                   while (nStackC) {
     10651                                        nStackC--;
     10652                                        int iColumn = stackColumn[nStackC];
     10653                                        int iColumn2 = mapColumn[iColumn];
     10654                                        assert (iColumn != iColumn2);
     10655                                        int length = columnLength[iColumn];
     10656                                        assert (length == columnLength[iColumn2]);
     10657                                        CoinBigIndex start = columnStart[iColumn];
     10658                                        CoinBigIndex offset2 = columnStart[iColumn2] - start;
     10659                                        for (CoinBigIndex i = start; i < start + length; i++) {
     10660                                             int iRow = row[i];
     10661                                             int iRow2 = row[i+offset2];
     10662                                             if (mapRow[iRow] == iRow) {
     10663                                                  // First (but be careful)
     10664                                                  if (iRow != iRow2) {
     10665                                                       //mapRow[iRow]=iRow2;
     10666                                                       //mapRow[iRow2]=iRow;
     10667                                                       int iBack = backRow[iRow];
     10668                                                       int iBack2 = backRow[iRow2];
     10669                                                       if (randomRow[iBack] == randomRow[iBack2] &&
     10670                                                                 iBack2 - iBack == offset) {
     10671                                                            stackRow[nStackR++] = iBack;
     10672                                                       } else {
     10673                                                            //printf("randomRow diff - weights %g %g\n",
     10674                                                            //     weight[iRow],weight[iRow2]);
     10675                                                            // bad
     10676                                                            good = false;
     10677                                                            break;
     10678                                                       }
     10679                                                  }
     10680                                             } else {
     10681                                                  if (mapRow[iRow] != iRow2 ||
     10682                                                            mapRow[iRow2] != iRow) {
     10683                                                       // bad
     10684                                                       good = false;
     10685                                                       printf("bad row\n");
     10686                                                       break;
     10687                                                  }
     10688                                             }
     10689                                        }
     10690                                        if (!good)
     10691                                             break;
     10692                                   }
     10693                              }
     10694                              // then check OK
     10695                              if (good) {
     10696                                   for (iRow = 0; iRow < numberRows; iRow++) {
     10697                                        CoinBigIndex start = rowStart[iRow];
     10698                                        int length = rowLength[iRow];
     10699                                        if (mapRow[iRow] == iRow) {
     10700                                             for (CoinBigIndex i = start; i < start + length; i++) {
     10701                                                  int jColumn = column[i];
     10702                                                  backColumn2[jColumn] = i - start;
     10703                                             }
     10704                                             for (CoinBigIndex i = start; i < start + length; i++) {
     10705                                                  int jColumn = column[i];
     10706                                                  if (mapColumn[jColumn] != jColumn) {
     10707                                                       int jColumn2 = mapColumn[jColumn];
     10708                                                       CoinBigIndex i2 = backColumn2[jColumn2];
     10709                                                       if (i2 < 0) {
     10710                                                            good = false;
     10711                                                       } else if (element[i] != element[i2+start]) {
     10712                                                            good = false;
     10713                                                       }
     10714                                                  }
     10715                                             }
     10716                                             for (CoinBigIndex i = start; i < start + length; i++) {
     10717                                                  int jColumn = column[i];
     10718                                                  backColumn2[jColumn] = -1;
     10719                                             }
     10720                                        } else {
     10721                                             int row2 = mapRow[iRow];
     10722                                             assert (iRow = mapRow[row2]);
     10723                                             if (rowLower[iRow] != rowLower[row2] ||
     10724                                                       rowLower[row2] != rowLower[iRow])
     10725                                                  good = false;
     10726                                             CoinBigIndex offset2 = rowStart[row2] - start;
     10727                                             for (CoinBigIndex i = start; i < start + length; i++) {
     10728                                                  int jColumn = column[i];
     10729                                                  double value = element[i];
     10730                                                  int jColumn2 = column[i+offset2];
     10731                                                  double value2 = element[i+offset2];
     10732                                                  if (value != value2 || mapColumn[jColumn] != jColumn2 ||
     10733                                                            mapColumn[jColumn2] != jColumn)
     10734                                                       good = false;
     10735                                             }
     10736                                        }
     10737                                   }
     10738                                   if (good) {
     10739                                        // check rim
     10740                                        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     10741                                             if (mapColumn[iColumn] != iColumn) {
     10742                                                  int iColumn2 = mapColumn[iColumn];
     10743                                                  if (objective[iColumn] != objective[iColumn2])
     10744                                                       good = false;
     10745                                                  if (columnLower[iColumn] != columnLower[iColumn2])
     10746                                                       good = false;
     10747                                                  if (columnUpper[iColumn] != columnUpper[iColumn2])
     10748                                                       good = false;
     10749                                                  if (model->isInteger(iColumn) != model->isInteger(iColumn2))
     10750                                                       good = false;
     10751                                             }
     10752                                        }
     10753                                   }
     10754                                   if (good) {
     10755                                        // temp
     10756                                        if (nMapRow < 0) {
     10757                                             //const double * solution = model->primalColumnSolution();
     10758                                             // find mapped
     10759                                             int nMapColumn = 0;
     10760                                             for (int i = 0; i < numberColumns; i++) {
     10761                                                  if (mapColumn[i] > i)
     10762                                                       nMapColumn++;
     10763                                             }
     10764                                             nMapRow = 0;
     10765                                             int kRow = -1;
     10766                                             for (int i = 0; i < numberRows; i++) {
     10767                                                  if (mapRow[i] > i) {
     10768                                                       nMapRow++;
     10769                                                       kRow = i;
     10770                                                  }
     10771                                             }
     10772                                             printf("%d columns, %d rows\n", nMapColumn, nMapRow);
     10773                                             if (nMapRow == 1) {
     10774                                                  CoinBigIndex start = rowStart[kRow];
     10775                                                  int length = rowLength[kRow];
     10776                                                  printf("%g <= ", rowLower[kRow]);
     10777                                                  for (CoinBigIndex i = start; i < start + length; i++) {
     10778                                                       int jColumn = column[i];
     10779                                                       if (mapColumn[jColumn] != jColumn)
     10780                                                            printf("* ");
     10781                                                       printf("%d,%g ", jColumn, element[i]);
     10782                                                  }
     10783                                                  printf("<= %g\n", rowUpper[kRow]);
     10784                                             }
     10785                                        }
     10786                                        // temp
     10787                                        int row1 = sortRow[lastLook];
     10788                                        int row2 = sortRow[jLook];
     10789                                        lastLook = jLook;
     10790                                        CoinBigIndex start1 = rowStart[row1];
     10791                                        CoinBigIndex offset2 = rowStart[row2] - start1;
     10792                                        int length = rowLength[row1];
     10793                                        assert( length == rowLength[row2]);
     10794                                        CoinBigIndex put = startAdd[nAddRows];
     10795                                        double multiplier = length < 11 ? 2.0 : 1.125;
     10796                                        double value = 1.0;
     10797                                        for (CoinBigIndex i = start1; i < start1 + length; i++) {
     10798                                             int jColumn1 = column[i];
     10799                                             int jColumn2 = column[i+offset2];
     10800                                             columnAdd[put] = jColumn1;
     10801                                             elementAdd[put++] = value;
     10802                                             columnAdd[put] = jColumn2;
     10803                                             elementAdd[put++] = -value;
     10804                                             value *= multiplier;
     10805                                        }
     10806                                        nAddRows++;
     10807                                        startAdd[nAddRows] = put;
     10808                                   } else {
     10809                                        printf("ouch - did not check out as good\n");
     10810                                   }
     10811                              }
     10812                         }
     10813                         // skip rest
     10814                         iLook += numberPossible - 1;
     10815                    }
     10816               }
     10817          }
     10818          if (nAddRows) {
     10819               double * lower = new double [nAddRows];
     10820               double * upper = new double[nAddRows];
     10821               int i;
     10822               //const double * solution = model->primalColumnSolution();
     10823               for (i = 0; i < nAddRows; i++) {
     10824                    lower[i] = 0.0;
     10825                    upper[i] = COIN_DBL_MAX;
     10826               }
     10827               printf("Adding %d rows with %d elements\n", nAddRows,
     10828                      startAdd[nAddRows]);
     10829               //ClpSimplex newModel(*model);
     10830               //newModel.addRows(nAddRows,lower,upper,startAdd,columnAdd,elementAdd);
     10831               //newModel.writeMps("modified.mps");
     10832               delete [] lower;
     10833               delete [] upper;
     10834          }
     10835          delete [] startAdd;
     10836          delete [] columnAdd;
     10837          delete [] elementAdd;
     10838          delete [] order;
     10839          delete [] other;
     10840          delete [] randomColumn;
     10841          delete [] weight;
     10842          delete [] randomRow;
     10843          delete [] sortRow;
     10844          delete [] backRow;
     10845          delete [] possibleRow;
     10846          delete [] sortColumn;
     10847          delete [] backColumn;
     10848          delete [] backColumn2;
     10849          delete [] possibleColumn;
     10850          delete [] mapRow;
     10851          delete [] mapColumn;
     10852          delete [] stackRow;
     10853          delete [] stackColumn;
     10854     }
     10855     delete [] number;
     10856     // Now do breakdown of ranges
     10857     breakdown("Elements", numberElements, elementByColumn);
     10858     breakdown("RowLower", numberRows, rowLower);
     10859     breakdown("RowUpper", numberRows, rowUpper);
     10860     breakdown("ColumnLower", numberColumns, columnLower);
     10861     breakdown("ColumnUpper", numberColumns, columnUpper);
     10862     breakdown("Objective", numberColumns, objective);
    969110863}
    969210864
Note: See TracChangeset for help on using the changeset viewer.