Changeset 1723 for trunk


Ignore:
Timestamp:
Apr 17, 2011 11:07:10 AM (9 years ago)
Author:
forrest
Message:

out some printf statements

Location:
trunk/Clp/src
Files:
18 edited

Legend:

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

    r1665 r1723  
    274274          for (iRow = 0; iRow < numberTotal; iRow++) {
    275275               if (rowsDropped_[iRow] && CoinAbs(array[iRow]) > 1.0e-8) {
    276                     printf("row region1 %d dropped %g\n", iRow, array[iRow]);
     276                 COIN_DETAIL_PRINT(printf("row region1 %d dropped %g\n", iRow, array[iRow]));
    277277               }
    278278          }
    279279          for (; iRow < numberRows_; iRow++) {
    280280               if (rowsDropped_[iRow] && CoinAbs(array[iRow]) > 1.0e-8) {
    281                     printf("row region2 %d dropped %g\n", iRow, array[iRow]);
     281                 COIN_DETAIL_PRINT(printf("row region2 %d dropped %g\n", iRow, array[iRow]));
    282282               }
    283283          }
     
    337337               for (iRow = numberRows_; iRow >= stop; iRow--) {
    338338                    if (used[iRow])
    339                          printf("%d columns are of length %d\n", used[iRow], iRow);
     339                      COIN_DETAIL_PRINT(printf("%d columns are of length %d\n", used[iRow], iRow));
    340340                    nLong += used[iRow];
    341341                    if (nLong > 50 || nLong > (numberColumns >> 2))
     
    363363                    dense_ = new ClpCholeskyDense();
    364364                    dense_->reserveSpace(NULL, numberDense);
    365                     printf("Taking %d columns as dense\n", numberDense);
     365                    COIN_DETAIL_PRINT(printf("Taking %d columns as dense\n", numberDense));
    366366               }
    367367          }
     
    703703               for (iRow = numberRows_; iRow >= stop; iRow--) {
    704704                    if (used[iRow])
    705                          printf("%d columns are of length %d\n", used[iRow], iRow);
     705                      COIN_DETAIL_PRINT(printf("%d columns are of length %d\n", used[iRow], iRow));
    706706                    nLong += used[iRow];
    707707                    if (nLong > 50 || nLong > (numberColumns >> 2))
     
    729729                    dense_ = new ClpCholeskyDense();
    730730                    dense_->reserveSpace(NULL, numberDense);
    731                     printf("Taking %d columns as dense\n", numberDense);
     731                    COIN_DETAIL_PRINT(printf("Taking %d columns as dense\n", numberDense));
    732732               }
    733733          }
     
    10511051               permuteInverse_[iRow] = done++;
    10521052     }
    1053      printf("%d compressions, %d expansions\n",
    1054             numberCompressions, numberExpansions);
     1053     COIN_DETAIL_PRINT(printf("%d compressions, %d expansions\n",
     1054                              numberCompressions, numberExpansions));
    10551055     assert (done == numberRows_);
    10561056     delete [] sort;
     
    26032603     // don't do if dense columns
    26042604     if (nDense >= DENSE_THRESHOLD && !dense_) {
    2605           printf("Going dense for last %d rows\n", nDense);
     2605       COIN_DETAIL_PRINT(printf("Going dense for last %d rows\n", nDense));
    26062606          // make sure we don't disturb any indices
    26072607          CoinBigIndex k = 0;
  • trunk/Clp/src/ClpCholeskyDense.cpp

    r1665 r1723  
    386386          smallest = doubleParameters_[4];
    387387          if (model_->messageHandler()->logLevel() > 1)
    388                std::cout << "Cholesky - largest " << largest << " smallest " << smallest << std::endl;
     388            COIN_DETAIL_PRINT(std::cout << "Cholesky - largest " << largest << " smallest " << smallest << std::endl);
    389389          choleskyCondition_ = largest / smallest;
    390390          /* Should save adjustments in ..R_*/
  • trunk/Clp/src/ClpCholeskyMumps.cpp

    r1692 r1723  
    259259     mumps_->a = sparseFactor_;
    260260     if (mumps_->infog[0]) {
    261           printf("MUMPS ordering failed -error %d %d\n",
    262                  mumps_->infog[0], mumps_->infog[1]);
     261          COIN_DETAIL_PRINT(printf("MUMPS ordering failed -error %d %d\n",
     262                                   mumps_->infog[0], mumps_->infog[1]));
    263263          return 1;
    264264     } else {
     
    266266          if (size < 0)
    267267               size *= -1000000;
    268           printf("%g nonzeros, flop count %g\n", size, mumps_->rinfog[0]);
     268          COIN_DETAIL_PRINT(printf("%g nonzeros, flop count %g\n", size, mumps_->rinfog[0]));
    269269     }
    270270     for (iRow = 0; iRow < numberRows_; iRow++) {
     
    385385     dmumps_c(mumps_);
    386386     if (mumps_->infog[0]) {
    387           printf("MUMPS factorization failed -error %d %d\n",
    388                  mumps_->infog[0], mumps_->infog[1]);
     387          COIN_DETAIL_PRINT(printf("MUMPS factorization failed -error %d %d\n",
     388                                   mumps_->infog[0], mumps_->infog[1]));
    389389     }
    390390     choleskyCondition_ = 1.0;
  • trunk/Clp/src/ClpCholeskyUfl.cpp

    r1691 r1723  
    259259     L_ = cholmod_analyze (&A, c_) ;
    260260     if (c_->status) {
    261           std::cout << "CHOLMOD ordering failed" << std::endl;
     261       COIN_DETAIL_PRINT(std::cout << "CHOLMOD ordering failed" << std::endl);
    262262          return 1;
    263263     } else {
    264           printf("%g nonzeros, flop count %g\n", c_->lnz, c_->fl);
     264       COIN_DETAIL_PRINT(printf("%g nonzeros, flop count %g\n", c_->lnz, c_->fl));
    265265     }
    266266     for (iRow = 0; iRow < numberRows_; iRow++) {
  • trunk/Clp/src/ClpCholeskyWssmp.cpp

    r1695 r1723  
    156156          for (iRow = numberRows_; iRow >= stop; iRow--) {
    157157               if (used[iRow])
    158                     printf("%d columns are of length %d\n", used[iRow], iRow);
     158                 COIN_DETAIL_PRINT(printf("%d columns are of length %d\n", used[iRow], iRow));
    159159               nLong += used[iRow];
    160160               if (nLong > 50 || nLong > (numberColumns >> 2))
     
    182182               dense_ = new ClpCholeskyDense();
    183183               dense_->reserveSpace(NULL, numberDense);
    184                printf("Taking %d columns as dense\n", numberDense);
     184               COIN_DETAIL_PRINT(printf("Taking %d columns as dense\n", numberDense));
    185185          }
    186186     }
  • trunk/Clp/src/ClpCholeskyWssmpKKT.cpp

    r1695 r1723  
    509509           NULL, permute_, permuteInverse_, array, &numberRows_, &i1,
    510510           NULL, &i0, NULL, integerParameters_, doubleParameters_);
    511 #if 1
     511#if 0
    512512     int iRow;
    513513     for (iRow = 0; iRow < numberTotal; iRow++) {
  • trunk/Clp/src/ClpModel.cpp

    r1710 r1723  
    13961396     if (maximumRows_ >= 0) {
    13971397          if (numberRows_ > maximumRows_)
    1398                printf("resize %d rows, %d old maximum rows\n",
    1399                       numberRows_, maximumRows_);
     1398               COIN_DETAIL_PRINT(printf("resize %d rows, %d old maximum rows\n",
     1399                                        numberRows_, maximumRows_));
    14001400          maximumRows_ = CoinMax(maximumRows_, numberRows_);
    14011401          maximumColumns_ = CoinMax(maximumColumns_, numberColumns_);
     
    39533953ClpModel::startPermanentArrays()
    39543954{
    3955      printf("startperm a %d rows, %d maximum rows\n",
    3956             numberRows_, maximumRows_);
     3955     COIN_DETAIL_PRINT(printf("startperm a %d rows, %d maximum rows\n",
     3956                              numberRows_, maximumRows_));
    39573957     if ((specialOptions_ & 65536) != 0) {
    39583958          if (numberRows_ > maximumRows_ || numberColumns_ > maximumColumns_) {
     
    39713971               // need to make sure numberRows_ OK and size of matrices
    39723972               resize(maximumRows_, maximumColumns_);
    3973                printf("startperm b %d rows, %d maximum rows\n",
    3974                       numberRows_, maximumRows_);
     3973               COIN_DETAIL_PRINT(printf("startperm b %d rows, %d maximum rows\n",
     3974                                        numberRows_, maximumRows_));
    39753975          } else {
    39763976               return;
     
    39853985          baseRowCopy_.setExtraMajor(0.0);
    39863986          baseRowCopy_.reverseOrderedCopyOf(baseMatrix_);
    3987           printf("startperm c %d rows, %d maximum rows\n",
    3988                  numberRows_, maximumRows_);
     3987          COIN_DETAIL_PRINT(printf("startperm c %d rows, %d maximum rows\n",
     3988                                   numberRows_, maximumRows_));
    39893989     }
    39903990}
  • trunk/Clp/src/ClpNonLinearCost.cpp

    r1677 r1723  
    274274
    275275     double whichWay = model_->optimizationDirection();
    276      printf("Direction %g\n", whichWay);
     276     COIN_DETAIL_PRINT(printf("Direction %g\n", whichWay));
    277277
    278278     numberInfeasibilities_ = 0;
  • trunk/Clp/src/ClpPackedMatrix.cpp

    r1722 r1723  
    49304930               }
    49314931               if (ok)
    4932                     printf("flags_ could be 0\n");
     4932                 COIN_DETAIL_PRINT(printf("flags_ could be 0\n"));
    49334933          }
    49344934     }
  • trunk/Clp/src/ClpPredictorCorrector.cpp

    r1665 r1723  
    141141     int returnCode = cholesky_->order(this);
    142142     if (returnCode || cholesky_->symbolic()) {
    143           printf("Error return from symbolic - probably not enough memory\n");
     143       COIN_DETAIL_PRINT(printf("Error return from symbolic - probably not enough memory\n"));
    144144          problemStatus_ = 4;
    145145          //delete all temporary regions
     
    164164     //initialize solution here
    165165     if(createSolution() < 0) {
    166           printf("Not enough memory\n");
     166       COIN_DETAIL_PRINT(printf("Not enough memory\n"));
    167167          problemStatus_ = 4;
    168168          //delete all temporary regions
     
    318318               if (saveIt) {
    319319#if KEEP_GOING_IF_FIXED<10
    320                     printf("saving\n");
     320                 COIN_DETAIL_PRINT(printf("saving\n"));
    321321#endif
    322322                    saveIteration = numberIterations_;
     
    349349                         bestKilled = numberFixedTotal;
    350350#if KEEP_GOING_IF_FIXED<10
    351                          printf("saving alternate\n");
     351                         COIN_DETAIL_PRINT(printf("saving alternate\n"));
    352352#endif
    353353                         saveIteration2 = numberIterations_;
     
    515515          if (newDropped) {
    516516               if (newDropped == -1) {
    517                     printf("Out of memory\n");
     517                 COIN_DETAIL_PRINT(printf("Out of memory\n"));
    518518                    problemStatus_ = 4;
    519519                    //delete all temporary regions
     
    741741                    //assert (goodMove);
    742742               }
    743                if (nHalve && handler_->logLevel() > 1)
     743               if (nHalve && handler_->logLevel() > 2)
    744744                    printf("halved %d times\n", nHalve);
    745745#endif
     
    882882          }
    883883          if (numberGoodTries && handler_->logLevel() > 1) {
    884                printf("%d centering steps moved from (gap %.18g, dual %.18g, primal %.18g) to (gap %.18g, dual %.18g, primal %.18g)\n",
     884               COIN_DETAIL_PRINT(printf("%d centering steps moved from (gap %.18g, dual %.18g, primal %.18g) to (gap %.18g, dual %.18g, primal %.18g)\n",
    885885                      numberGoodTries, static_cast<double>(nextGap), static_cast<double>(originalDualStep),
    886886                      static_cast<double>(originalPrimalStep),
    887887                      static_cast<double>(nextCenterGap), static_cast<double>(actualDualStep_),
    888                       static_cast<double>(actualPrimalStep_));
     888                                        static_cast<double>(actualPrimalStep_)));
    889889          }
    890890          // save last gap
     
    944944     //#ifdef SOME_DEBUG
    945945     if (handler_->logLevel() > 1)
    946           printf("ENDRUN status %d after %d iterations\n", problemStatus_, numberIterations_);
     946       COIN_DETAIL_PRINT(printf("ENDRUN status %d after %d iterations\n", problemStatus_, numberIterations_));
    947947     //#endif
    948948     //std::cout<<"Absolute primal infeasibility at end "<<sumPrimalInfeasibilities_<<std::endl;
     
    17371737                    CoinFillN(deltaX_, numberTotal, static_cast<CoinWorkDouble>(1.0));
    17381738                    CoinFillN(deltaY_, numberRows_, static_cast<CoinWorkDouble>(1.0));
    1739                     printf("bad cholesky\n");
     1739                    COIN_DETAIL_PRINT(printf("bad cholesky\n"));
    17401740               }
    17411741          }
     
    20132013     int returnCode = cholesky_->factorize(diagonal_, rowsDropped);
    20142014     if (returnCode == -1) {
    2015           printf("Out of memory\n");
     2015       COIN_DETAIL_PRINT(printf("Out of memory\n"));
    20162016          problemStatus_ = 4;
    20172017          return -1;
     
    34253425                                                     (nextMu - complementarity) / lowerSlack_[iColumn]);
    34263426                                        dualInfeasibility -= change;
    3427                                         printf("%d lb locomp %g - dual inf from %g to %g\n",
     3427                                        COIN_DETAIL_PRINT(printf("%d lb locomp %g - dual inf from %g to %g\n",
    34283428                                               iColumn, complementarity, dualInfeasibility + change,
    3429                                                dualInfeasibility);
     3429                                                                 dualInfeasibility));
    34303430                                        zVec_[iColumn] += change;
    34313431                                        zValue = CoinMax(zVec_[iColumn], 1.0e-12);
     
    34393439                                                     (complementarity - nextMu) / upperSlack_[iColumn]);
    34403440                                        dualInfeasibility -= change;
    3441                                         printf("%d ub hicomp %g - dual inf from %g to %g\n",
     3441                                        COIN_DETAIL_PRINT(printf("%d ub hicomp %g - dual inf from %g to %g\n",
    34423442                                               iColumn, complementarity, dualInfeasibility + change,
    3443                                                dualInfeasibility);
     3443                                                                 dualInfeasibility));
    34443444                                        wVec_[iColumn] -= change;
    34453445                                        wValue = CoinMax(wVec_[iColumn], 1.0e-12);
     
    34553455                                                     (nextMu - complementarity) / lowerSlack_[iColumn]);
    34563456                                        dualInfeasibility -= change;
    3457                                         printf("%d lb hicomp %g - dual inf from %g to %g\n",
     3457                                        COIN_DETAIL_PRINT(printf("%d lb hicomp %g - dual inf from %g to %g\n",
    34583458                                               iColumn, complementarity, dualInfeasibility + change,
    3459                                                dualInfeasibility);
     3459                                                                 dualInfeasibility));
    34603460                                        zVec_[iColumn] += change;
    34613461                                        zValue = CoinMax(zVec_[iColumn], 1.0e-12);
     
    34693469                                                     (complementarity - nextMu) / upperSlack_[iColumn]);
    34703470                                        dualInfeasibility -= change;
    3471                                         printf("%d ub locomp %g - dual inf from %g to %g\n",
     3471                                        COIN_DETAIL_PRINT(printf("%d ub locomp %g - dual inf from %g to %g\n",
    34723472                                               iColumn, complementarity, dualInfeasibility + change,
    3473                                                dualInfeasibility);
     3473                                                                 dualInfeasibility));
    34743474                                        wVec_[iColumn] -= change;
    34753475                                        wValue = CoinMax(wVec_[iColumn], 1.0e-12);
     
    35403540                    if (solution_[iColumn] != lower_[iColumn] &&
    35413541                              solution_[iColumn] != upper_[iColumn]) {
    3542                          printf("%d %g %g %g\n", iColumn, static_cast<double>(lower_[iColumn]),
    3543                                 static_cast<double>(solution_[iColumn]), static_cast<double>(upper_[iColumn]));
     3542                         COIN_DETAIL_PRINT(printf("%d %g %g %g\n", iColumn, static_cast<double>(lower_[iColumn]),
     3543                                                  static_cast<double>(solution_[iColumn]), static_cast<double>(upper_[iColumn])));
    35443544                    }
    35453545                    diagonal_[iColumn] = 0.0;
  • trunk/Clp/src/ClpPresolve.cpp

    r1721 r1723  
    596596#if IMPLIED>2&&IMPLIED<11
    597597               fill_level = IMPLIED;
    598                printf("** fill_level == %d !\n", fill_level);
     598               COIN_DETAIL_PRINT(printf("** fill_level == %d !\n", fill_level));
    599599#endif
    600600#if IMPLIED>11&&IMPLIED<21
    601601               fill_level = -(IMPLIED - 10);
    602                printf("** fill_level == %d !\n", fill_level);
     602               COIN_DETAIL_PRINT(printf("** fill_level == %d !\n", fill_level));
    603603#endif
    604604#endif
  • trunk/Clp/src/ClpPrimalColumnSteepest.cpp

    r1665 r1723  
    272272                    saveWeights(model_, 4);
    273273                    anyUpdates = 0;
    274                     printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio);
     274                    COIN_DETAIL_PRINT(printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio));
    275275               }
    276276               if (switchType == 5) {
    277277                    numberLook *= 5; // needs tuning for gub
    278278                    if (model_->numberIterations() % 1000 == 0 && model_->logLevel() > 1) {
    279                          printf("numels %d ratio %g wanted %d look %d\n",
    280                                 sizeFactorization_, ratio, numberWanted, numberLook);
     279                         COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d look %d\n",
     280                                                  sizeFactorization_, ratio, numberWanted, numberLook));
    281281                    }
    282282                    // Update duals and row djs
     
    402402               weights_ = NULL;
    403403               saveWeights(model_, 4);
    404                printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio);
     404               COIN_DETAIL_PRINT(printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio));
    405405          }
    406406          //if (model_->numberIterations()%1000==0)
     
    432432               weights_ = NULL;
    433433               saveWeights(model_, 4);
    434                printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio);
     434               COIN_DETAIL_PRINT(printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio));
    435435               updates->clear();
    436436          }
    437437          if (model_->numberIterations() % 1000 == 0)
    438                printf("numels %d ratio %g wanted %d type x\n", sizeFactorization_, ratio, numberWanted);
     438            COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d type x\n", sizeFactorization_, ratio, numberWanted));
    439439     }
    440440     if (switchType < 4) {
     
    24212421               weights_ = NULL;
    24222422               saveWeights(model_, 4);
    2423                printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio);
     2423               COIN_DETAIL_PRINT(printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio));
    24242424               updates->clear();
    24252425          }
    24262426          if (model_->numberIterations() % 1000 == 0)
    2427                printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted);
     2427            COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted));
    24282428     }
    24292429     if(switchType == 4) {
     
    24512451               weights_ = NULL;
    24522452               saveWeights(model_, 4);
    2453                printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio);
     2453               COIN_DETAIL_PRINT(printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio));
    24542454               updates->clear();
    24552455          }
    24562456          if (model_->numberIterations() % 1000 == 0)
    2457                printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted);
     2457            COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted));
    24582458     }
    24592459     if (switchType < 4) {
     
    32903290     double check = CoinMax(devex, oldDevex);;
    32913291     if ( fabs ( devex - oldDevex ) > relativeTolerance * check ) {
    3292           printf("check %d old weight %g, new %g\n", sequence, oldDevex, devex);
     3292       COIN_DETAIL_PRINT(printf("check %d old weight %g, new %g\n", sequence, oldDevex, devex));
    32933293          // update so won't print again
    32943294          weights_[sequence] = devex;
     
    36213621     double * duals2 = duals - numberColumns;
    36223622     int chunk = CoinMin(1024, (numberColumns + nSlacks) / 32);
     3623#ifdef COIN_DETAIL
    36233624     if (model_->numberIterations() % 1000 == 0 && model_->logLevel() > 1) {
    36243625          printf("%d wanted, nSlacks %d, chunk %d\n", numberWanted, nSlacks, chunk);
     
    36283629          printf("\n");
    36293630     }
     3631#endif
    36303632     chunk = CoinMax(chunk, 256);
    36313633     bool finishedR = false, finishedC = false;
  • trunk/Clp/src/ClpQuadraticObjective.cpp

    r1665 r1723  
    756756               return maximumTheta;
    757757          } else {
    758                printf("odd linear direction %g\n", delta);
     758            COIN_DETAIL_PRINT(printf("odd linear direction %g\n", delta));
    759759               return 0.0;
    760760          }
  • trunk/Clp/src/ClpSimplex.cpp

    r1722 r1723  
    19161916                    }
    19171917                    solution->numberUnsatisfied[solution->numberSolutions++] = numberUnsat;
    1918                     printf("iteration %d, %d unsatisfied (%g,%g), %d fixed, %d satisfied\n",
    1919                            numberIterations_, numberUnsat, sumUnsat, mostAway, numberFixed, numberSat);
     1918                    COIN_DETAIL_PRINT(printf("iteration %d, %d unsatisfied (%g,%g), %d fixed, %d satisfied\n",
     1919                                             numberIterations_, numberUnsat, sumUnsat, mostAway, numberFixed, numberSat));
    19201920               }
    19211921          }
     
    30593059               newArrays = true;
    30603060               keepPivots = false;
    3061                printf("createrim a %d rows, %d maximum rows %d maxinternal\n",
    3062                       numberRows_, maximumRows_, maximumInternalRows_);
     3061               COIN_DETAIL_PRINT(printf("createrim a %d rows, %d maximum rows %d maxinternal\n",
     3062                                        numberRows_, maximumRows_, maximumInternalRows_));
    30633063               int oldMaximumRows = maximumInternalRows_;
    30643064               int oldMaximumColumns = maximumInternalColumns_;
     
    30743074               assert(maximumInternalRows_ == maximumRows_);
    30753075               assert(maximumInternalColumns_ == maximumColumns_);
    3076                printf("createrim b %d rows, %d maximum rows, %d maxinternal\n",
    3077                       numberRows_, maximumRows_, maximumInternalRows_);
     3076               COIN_DETAIL_PRINT(printf("createrim b %d rows, %d maximum rows, %d maxinternal\n",
     3077                                        numberRows_, maximumRows_, maximumInternalRows_));
    30783078               int numberTotal2 = (maximumInternalRows_ + maximumInternalColumns_) * 2;
    30793079               delete [] cost_;
     
    32243224                         }
    32253225                    }
    3226                     printf("small obj %g, large %g - rhs %g\n", smallestObj, largestObj, largestRhs);
     3226                    COIN_DETAIL_PRINT(printf("small obj %g, large %g - rhs %g\n", smallestObj, largestObj, largestRhs));
    32273227                    bool scalingDone = false;
    32283228                    // look at element range
     
    46024602     //assert (infiniteUpperC==infiniteUpper);
    46034603     if (fabs(maximumUp - maximumUpC) > 1.0e-12 * CoinMax(fabs(maximumUp), fabs(maximumUpC)))
    4604           printf("row %d comp up %g, true up %g\n", iRow,
    4605                  maximumUpC, maximumUp);
     4604          COIN_DETAIL_PRINT(printf("row %d comp up %g, true up %g\n", iRow,
     4605                                   maximumUpC, maximumUp));
    46064606     if (fabs(maximumDown - maximumDownC) > 1.0e-12 * CoinMax(fabs(maximumDown), fabs(maximumDownC)))
    4607           printf("row %d comp down %g, true down %g\n", iRow,
    4608                  maximumDownC, maximumDown);
     4607          COIN_DETAIL_PRINT(printf("row %d comp down %g, true down %g\n", iRow,
     4608                 maximumDownC, maximumDown));
    46094609     maximumUpC = maximumUp;
    46104610     maximumDownC = maximumDown;
     
    81068106          return 0;
    81078107     } else {
    8108           printf("Return code of %d from ClpSimplexPrimal::pivotResult\n",
    8109                  returnCode);
     8108          COIN_DETAIL_PRINT(printf("Return code of %d from ClpSimplexPrimal::pivotResult\n",
     8109                                   returnCode));
    81108110          return -1;
    81118111     }
     
    86548654     int iColumn;
    86558655     int numberTotal = numberRows_ + numberColumns;
    8656      printf("%d %d %d\n", numberTotal, numberRows_, numberColumns);
     8656     COIN_DETAIL_PRINT(printf("%d %d %d\n", numberTotal, numberRows_, numberColumns));
    86578657     // mapping
    86588658     int * mapping = new int[numberRows_+numberColumns_];
     
    87528752          rowSolution[iRow] -= sumFixed[iRow];
    87538753     }
    8754      printf("offset %g sumfixed %g\n", offset, fixed);
     8754     COIN_DETAIL_PRINT(printf("offset %g sumfixed %g\n", offset, fixed));
    87558755     delete [] sumFixed;
    87568756     columnScale_ = wholeModel->columnScale_;
     
    87918791     wholeModel->nonLinearCost_ = new ClpNonLinearCost(wholeModel);
    87928792     wholeModel->nonLinearCost_->checkInfeasibilities();
    8793      printf("after contraction %d infeasibilities summing to %g\n",
    8794             nonLinearCost_->numberInfeasibilities(), nonLinearCost_->sumInfeasibilities());
     8793     COIN_DETAIL_PRINT(printf("after contraction %d infeasibilities summing to %g\n",
     8794                              nonLinearCost_->numberInfeasibilities(), nonLinearCost_->sumInfeasibilities()));
    87958795     // Redo some stuff
    87968796     wholeModel->reducedCostWork_ = wholeModel->dj_;
     
    89528952     delete [] sumFixed;
    89538953     nonLinearCost_->checkInfeasibilities();
    8954      printf("in original %d infeasibilities summing to %g\n",
    8955             nonLinearCost_->numberInfeasibilities(), nonLinearCost_->sumInfeasibilities());
     8954     COIN_DETAIL_PRINT(printf("in original %d infeasibilities summing to %g\n",
     8955                              nonLinearCost_->numberInfeasibilities(), nonLinearCost_->sumInfeasibilities()));
    89568956     // Initialize weights
    89578957     primalColumnPivot_ = new ClpPrimalColumnSteepest(10);
     
    1001010010          }
    1001110011     }
    10012      printf("resetbase a %d rows, %d maximum rows\n",
    10013             numberRows_, maximumRows_);
     10012     COIN_DETAIL_PRINT(printf("resetbase a %d rows, %d maximum rows\n",
     10013                              numberRows_, maximumRows_));
    1001410014     // temporary - later use maximumRows_ for rowUpper_ etc
    1001510015     assert (numberRows_ >= model->numberRows_);
     
    1108611086                              info->large_->columnUpper_[iColumn] = columnUpper_[i];
    1108711087                              info->large_->columnLower_[iColumn] = columnLower_[i];
    11088                               printf("%d dj %g dual %g scale %g\n",
    11089                                      iColumn, dj_[i], reducedCost_[i], columnScale_[i]);
     11088                              COIN_DETAIL_PRINT(printf("%d dj %g dual %g scale %g\n",
     11089                                                       iColumn, dj_[i], reducedCost_[i], columnScale_[i]));
    1109011090
    1109111091                         }
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1717 r1723  
    19541954                                   }
    19551955                                   if (bad >= 0)
    1956                                         printf("bad %d old %g new %g\n", bad, comp[bad], solution_[bad]);
     1956                                     COIN_DETAIL_PRINT(printf("bad %d old %g new %g\n", bad, comp[bad], solution_[bad]));
    19571957#endif
    19581958                                   checkPrimalSolution(rowActivityWork_, columnActivityWork_);
     
    47264726                                   if (numberDualInfeasibilities_) {
    47274727                                        if (fabs(changeCost) > 1.0e-5)
    4728                                              printf("Odd free/unbounded combo\n");
     4728                                          COIN_DETAIL_PRINT(printf("Odd free/unbounded combo\n"));
    47294729                                        changeCost += cost_[iChosen];
    47304730                                   }
     
    67136713                    alpha = work[i];
    67146714                    if (addSequence) {
    6715                          printf("possible - pivot row %d this %d\n", pivotRow_, iSequence);
     6715                      COIN_DETAIL_PRINT(printf("possible - pivot row %d this %d\n", pivotRow_, iSequence));
    67166716                         oldValue = dj_[iSequence2];
    67176717                         if (alpha <= -acceptablePivot) {
     
    73127312#ifndef NDEBUG
    73137313     } else {
    7314           printf("NULL lower\n");
     7314       COIN_DETAIL_PRINT(printf("NULL lower\n"));
    73157315#endif
    73167316     }
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1717 r1723  
    336336                              primalColumnPivot_->switchOffSprint();
    337337                         //lastSprintIteration=numberIterations_;
    338                          printf("End small model\n");
     338                         COIN_DETAIL_PRINT(printf("End small model\n"));
    339339                    }
    340340               }
     
    369369                    saveModel = NULL;
    370370                    //lastSprintIteration=numberIterations_;
    371                     printf("End small model after\n");
     371                    COIN_DETAIL_PRINT(printf("End small model after\n"));
    372372                    statusOfProblemInPrimal(lastCleaned, factorType, &progress_, true, ifValuesPass, saveModel);
    373373               }
     
    432432                    if (objectiveValue()*optimizationDirection_ > lastObjectiveValue - 1.0e-7 && sprintPass > 5) {
    433433                         // switch off
    434                          printf("Switching off sprint\n");
     434                      COIN_DETAIL_PRINT(printf("Switching off sprint\n"));
    435435                         primalColumnPivot_->switchOffSprint();
    436436                    } else {
     
    448448                         //statusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,saveModel);
    449449                         stopSprint = numberIterations_ + numberSprintIterations;
    450                          printf("Sprint with %d columns for %d iterations\n",
    451                                 numberSprintColumns, numberSprintIterations);
     450                         COIN_DETAIL_PRINT(printf("Sprint with %d columns for %d iterations\n",
     451                                                  numberSprintColumns, numberSprintIterations));
    452452                    }
    453453               }
     
    14381438     }
    14391439     if (problemStatus_ == 0) {
    1440           double objVal = nonLinearCost_->feasibleCost();
     1440          double objVal = (nonLinearCost_->feasibleCost()
     1441                        + objective_->nonlinearOffset());
     1442          objVal /= (objectiveScale_ * rhsScale_);
    14411443          double tol = 1.0e-10 * CoinMax(fabs(objVal), fabs(objectiveValue_)) + 1.0e-8;
    14421444          if (fabs(objVal - objectiveValue_) > tol) {
     
    17471749               double thruCost = infeasibilityCost_ * spare[pivotOne];
    17481750               if (thruCost >= 0.99 * fabs(dualIn_))
    1749                     printf("Could pivot on %d as change %g dj %g\n",
    1750                            index[pivotOne], thruCost, dualIn_);
     1751                    COIN_DETAIL_PRINT(printf("Could pivot on %d as change %g dj %g\n",
     1752                                             index[pivotOne], thruCost, dualIn_));
    17511753               double alpha = spare[pivotOne];
    17521754               double oldValue = rhs[pivotOne];
     
    20362038                    if (dualIn_ < 0.0) {
    20372039                         // move to other side
    2038                          printf("For %d U (%g, %g, %g) dj changed from %g",
     2040                         COIN_DETAIL_PRINT(printf("For %d U (%g, %g, %g) dj changed from %g",
    20392041                                sequenceIn_, lower_[sequenceIn_], solution_[sequenceIn_],
    2040                                 upper_[sequenceIn_], dualIn_);
     2042                                                  upper_[sequenceIn_], dualIn_));
    20412043                         dualIn_ -= nonLinearCost_->changeUpInCost(sequenceIn_);
    2042                          printf(" to %g\n", dualIn_);
     2044                         COIN_DETAIL_PRINT(printf(" to %g\n", dualIn_));
    20432045                         nonLinearCost_->setOne(sequenceIn_, upper_[sequenceIn_] + 2.0 * currentPrimalTolerance());
    20442046                         setStatus(sequenceIn_, ClpSimplex::atLowerBound);
     
    20482050                    if (dualIn_ > 0.0) {
    20492051                         // move to other side
    2050                          printf("For %d L (%g, %g, %g) dj changed from %g",
     2052                         COIN_DETAIL_PRINT(printf("For %d L (%g, %g, %g) dj changed from %g",
    20512053                                sequenceIn_, lower_[sequenceIn_], solution_[sequenceIn_],
    2052                                 upper_[sequenceIn_], dualIn_);
     2054                                                  upper_[sequenceIn_], dualIn_));
    20532055                         dualIn_ -= nonLinearCost_->changeDownInCost(sequenceIn_);
    2054                          printf(" to %g\n", dualIn_);
     2056                         COIN_DETAIL_PRINT(printf(" to %g\n", dualIn_));
    20552057                         nonLinearCost_->setOne(sequenceIn_, lower_[sequenceIn_] - 2.0 * currentPrimalTolerance());
    20562058                         setStatus(sequenceIn_, ClpSimplex::atUpperBound);
     
    31913193               statusOfProblemInPrimal(lastCleaned, 0, &dummyProgress, true, ifValuesPass);
    31923194          if (problemStatus_ == 5) {
    3193                printf("Singular basis\n");
     3195            COIN_DETAIL_PRINT(printf("Singular basis\n"));
    31943196               problemStatus_ = -1;
    31953197               returnCode = 5;
     
    34913493                              primalColumnPivot_->switchOffSprint();
    34923494                         //lastSprintIteration=numberIterations_;
    3493                          printf("End small model\n");
     3495                         COIN_DETAIL_PRINT(printf("End small model\n"));
    34943496                    }
    34953497               }
     
    35243526                    saveModel = NULL;
    35253527                    //lastSprintIteration=numberIterations_;
    3526                     printf("End small model after\n");
     3528                    COIN_DETAIL_PRINT(printf("End small model after\n"));
    35273529                    statusOfProblemInPrimal(lastCleaned, factorType, &progress_, true, ifValuesPass, saveModel);
    35283530               }
     
    35873589                    if (objectiveValue()*optimizationDirection_ > lastObjectiveValue - 1.0e-7 && sprintPass > 5) {
    35883590                         // switch off
    3589                          printf("Switching off sprint\n");
     3591                      COIN_DETAIL_PRINT(printf("Switching off sprint\n"));
    35903592                         primalColumnPivot_->switchOffSprint();
    35913593                    } else {
     
    36033605                         //statusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,saveModel);
    36043606                         stopSprint = numberIterations_ + numberSprintIterations;
    3605                          printf("Sprint with %d columns for %d iterations\n",
    3606                                 numberSprintColumns, numberSprintIterations);
     3607                         COIN_DETAIL_PRINT(printf("Sprint with %d columns for %d iterations\n",
     3608                                                  numberSprintColumns, numberSprintIterations));
    36073609                    }
    36083610               }
     
    36473649                         progress_.fillFromModel(this);
    36483650                         progress_.startCheck();
    3649                          printf("%d degenerate after %d iterations\n", numberDegen,
    3650                                 numberIterations_);
     3651                         COIN_DETAIL_PRINT(printf("%d degenerate after %d iterations\n", numberDegen,
     3652                                                  numberIterations_));
    36513653                         if (!numberDegen) {
    36523654                              CoinMemcpyN(originalCost, numberTotal, cost_);
     
    36633665                         continue;
    36643666                    } else {
    3665                          printf("exiting after %d iterations\n", numberIterations_);
     3667                      COIN_DETAIL_PRINT(printf("exiting after %d iterations\n", numberIterations_));
    36663668                         break;
    36673669                    }
  • trunk/Clp/src/IdiSolve.cpp

    r1665 r1723  
    265265                    if (fabs(smaller) > 1.0e10) {
    266266                         if (!nbad)
    267                               printf("Can't handle rows where both bounds >1.0e10 %d %g\n",
    268                                      i, smaller);
     267                              COIN_DETAIL_PRINT(printf("Can't handle rows where both bounds >1.0e10 %d %g\n",
     268                                                       i, smaller));
    269269                         nbad++;
    270270                         if (rowupper[i] < 0.0 || rowlower[i] > 0.0)
     
    295295          }
    296296          if (nbad)
    297                printf("%d bad values - results may be wrong\n", nbad);
     297            COIN_DETAIL_PRINT(printf("%d bad values - results may be wrong\n", nbad));
    298298     }
    299299     for (i = 0; i < nrows; i++) {
     
    770770                    if (saveSol) {
    771771                         if (result.weighted < bestSol) {
    772                               printf("%d %g better than %g\n", iter,
    773                                      result.weighted * maxmin - useOffset, bestSol * maxmin - useOffset);
     772                              COIN_DETAIL_PRINT(printf("%d %g better than %g\n", iter,
     773                                                       result.weighted * maxmin - useOffset, bestSol * maxmin - useOffset));
    774774                              bestSol = result.weighted;
    775775                              CoinMemcpyN(colsol, ncols, saveSol);
     
    10961096RETURN:
    10971097     if (kgood || kbad) {
    1098           printf("%g good %g bad\n", kgood, kbad);
     1098       COIN_DETAIL_PRINT(printf("%g good %g bad\n", kgood, kbad));
    10991099     }
    11001100     result = objval(nrows, ncols, rowsol, colsol, pi, djs, useCost,
     
    11111111               CoinMemcpyN(colsol, ncols, saveSol);
    11121112          } else {
    1113                printf("restoring previous - now %g best %g\n",
    1114                       result.weighted * maxmin - useOffset, bestSol * maxmin - useOffset);
     1113               COIN_DETAIL_PRINT(printf("restoring previous - now %g best %g\n",
     1114                                        result.weighted * maxmin - useOffset, bestSol * maxmin - useOffset));
    11151115          }
    11161116     }
  • trunk/Clp/src/Idiot.cpp

    r1665 r1723  
    614614     slackStart = countCostedSlacks(model_);
    615615     if (slackStart >= 0) {
    616           printf("This model has costed slacks\n");
     616       COIN_DETAIL_PRINT(printf("This model has costed slacks\n"));
    617617          slackEnd = slackStart + nrows;
    618618          if (slackStart) {
     
    894894                         if ((saveStrategy & 32) != 0 && result.infeas < reasonableInfeas && 0) {
    895895                              reasonableInfeas = CoinMax(smallInfeas, reasonableInfeas * sqrt(changeMu));
    896                               printf("reasonable infeas now %g\n", reasonableInfeas);
     896                              COIN_DETAIL_PRINT(printf("reasonable infeas now %g\n", reasonableInfeas));
    897897                         }
    898898                         result.weighted = 1.0e60;
     
    11281128     if ((strategy_ & 1024) != 0) {
    11291129          double ratio = static_cast<double> (ncols) / static_cast<double> (nrows);
    1130           printf("col/row ratio %g infeas ratio %g\n", ratio, lastResult.infeas / firstInfeas);
     1130          COIN_DETAIL_PRINT(printf("col/row ratio %g infeas ratio %g\n", ratio, lastResult.infeas / firstInfeas));
    11311131          if (lastResult.infeas > 0.01 * firstInfeas * ratio) {
    11321132               strategy_ &= (~1024);
    1133                printf(" - layer off\n");
     1133               COIN_DETAIL_PRINT(printf(" - layer off\n"));
    11341134          } else {
    1135                printf(" - layer on\n");
     1135            COIN_DETAIL_PRINT(printf(" - layer on\n"));
    11361136          }
    11371137     }
     
    12731273               objValue += value * cost[i+slackStart];
    12741274          }
    1275           printf("New objective after scaling %g\n", objValue);
     1275          COIN_DETAIL_PRINT(printf("New objective after scaling %g\n", objValue));
    12761276     }
    12771277#if 0
     
    16921692                         }
    16931693                    }
    1694                     printf("sum of infeasibilities %g\n", sum);
     1694                    COIN_DETAIL_PRINT(printf("sum of infeasibilities %g\n", sum));
    16951695                    delete [] rhs;
    16961696               }
Note: See TracChangeset for help on using the changeset viewer.