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

out some printf statements

File:
1 edited

Legend:

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

    r1639 r1641  
    18401840        CglStored * storedCuts = dupcuts.outDuplicates(solver_);
    18411841        if (storedCuts) {
    1842             printf("adding dup cuts\n");
     1842          COIN_DETAIL_PRINT(printf("adding dup cuts\n"));
    18431843            addCutGenerator(storedCuts, 1, "StoredCuts from dominated",
    18441844                            true, false, false, -200);
     
    23662366            }
    23672367            if (nTightened)
    2368                 printf("%d tightened by alternate cuts\n", nTightened);
     2368              COIN_DETAIL_PRINT(printf("%d tightened by alternate cuts\n", nTightened));
    23692369            if (storedRowCuts_->bestObjective() < bestObjective_) {
    23702370                // B) best solution
     
    24932493                        }
    24942494                        if (nTightened)
    2495                             printf("%d tightened by alternate cuts\n", nTightened);
     2495                          COIN_DETAIL_PRINT(printf("%d tightened by alternate cuts\n", nTightened));
    24962496                        if (storedRowCuts_->bestObjective() < bestObjective_) {
    24972497                            // B) best solution
     
    25342534                            addedCuts_[i] = new CbcCountRowCut(*cuts.rowCutPtr(i),
    25352535                                                               NULL, -1, -1, 2);
    2536                         printf("size %d\n", cuts.sizeRowCuts());
     2536                        COIN_DETAIL_PRINT(printf("size %d\n", cuts.sizeRowCuts()));
    25372537                        cuts = OsiCuts();
    25382538                        currentNumberCuts_ = maximumNumberCuts_;
     
    30453045                order[iColumn] = iColumn;
    30463046            }
    3047             printf("** can fix %d columns - best ratio for others is %g on gap of %g\n",
    3048                    nFix, bestRatio, gap);
     3047            COIN_DETAIL_PRINT(printf("** can fix %d columns - best ratio for others is %g on gap of %g\n",
     3048                                     nFix, bestRatio, gap));
    30493049            int nNeg = 0;
    30503050            CoinSort_2(saveLower, saveLower + numberColumns, order);
     
    30663066#endif
    30673067            }
    3068             printf("nAtLbNat %d,nAtUbNat %d,nAtLbNatZero %d,nAtUbNatZero %d,nAtLbFixed %d,nAtUbFixed %d,nAtOther %d,nAtOtherNat %d, useless %d %d\n",
     3068            COIN_DETAIL_PRINT(printf("nAtLbNat %d,nAtUbNat %d,nAtLbNatZero %d,nAtUbNatZero %d,nAtLbFixed %d,nAtUbFixed %d,nAtOther %d,nAtOtherNat %d, useless %d %d\n",
    30693069                   nAtLbNatural,
    30703070                   nAtUbNatural,
     
    30743074                   nAtUbFixed,
    30753075                   nAtOther,
    3076                    nAtOtherNatural, nNotNeeded, nNeg);
     3076                                     nAtOtherNatural, nNotNeeded, nNeg));
    30773077            delete [] saveLower;
    30783078            delete [] saveUpper;
     
    31053105            numberFixedAtRoot_ = newNode->analyze(this, analyzeResults_);
    31063106            if (numberFixedAtRoot_ > 0) {
    3107                 printf("%d fixed by analysis\n", numberFixedAtRoot_);
     3107              COIN_DETAIL_PRINT(printf("%d fixed by analysis\n", numberFixedAtRoot_));
    31083108                setPointers(solver_);
    31093109                numberFixedNow_ = numberFixedAtRoot_;
    31103110            } else if (numberFixedAtRoot_ < 0) {
    3111                 printf("analysis found to be infeasible\n");
     3111              COIN_DETAIL_PRINT(printf("analysis found to be infeasible\n"));
    31123112                anyAction = -2;
    31133113                delete newNode ;
     
    36303630                }
    36313631                if (newCutoff == -COIN_DBL_MAX) {
    3632                     printf("Root analysis says finished\n");
     3632                  COIN_DETAIL_PRINT(printf("Root analysis says finished\n"));
    36333633                } else if (n > numberFixedNow_) {
    3634                     printf("%d more fixed by analysis - now %d\n", n - numberFixedNow_, n);
     3634                  COIN_DETAIL_PRINT(printf("%d more fixed by analysis - now %d\n", n - numberFixedNow_, n));
    36353635                    numberFixedNow_ = n;
    36363636                }
     
    61616161        }
    61626162        if (!feasible) {
    6163             printf("analysis says node infeas\n");
     6163          COIN_DETAIL_PRINT(printf("analysis says node infeas\n"));
    61646164            cutoff = -COIN_DBL_MAX;
    61656165        }
     
    81918191            howOften = 0;
    81928192            if (howOften) {
    8193                 printf("** method 1\n");
     8193              COIN_DETAIL_PRINT(printf("** method 1\n"));
    81948194                //CglProbing * probing = dynamic_cast<CglProbing*>(generator_[iProbing]->generator());
    81958195                generator_[iProbing]->setWhatDepth(1);
     
    93669366    */
    93679367    if (numberCliques > 0 && numberSlacks && makeEquality) {
    9368         printf("adding %d integer slacks\n", numberSlacks);
     9368      COIN_DETAIL_PRINT(printf("adding %d integer slacks\n", numberSlacks));
    93699369        // add variables to make equality rows
    93709370        int * temp = new int[numberIntegers_+numberSlacks];
     
    1080010800                        } else {
    1080110801                            // obviously wrong
    10802                             if (handler_->logLevel() > 0)
     10802                            if (handler_->logLevel() > 1)
    1080310803                                printf("Cut generator %s set to run on new solution but NOT globally valid!!\n",
    1080410804                                       generator_[i]->cutGeneratorName());
     
    1151011510                    solver->setColLower(iColumn, newLower);
    1151111511                    solver->setColUpper(iColumn, newUpper);
    11512                     printf("Column %d, new bounds %g %g\n", iColumn,
    11513                            newLower, newUpper);
     11512                    COIN_DETAIL_PRINT(printf("Column %d, new bounds %g %g\n", iColumn,
     11513                                             newLower, newUpper));
    1151411514                } else if (vub[iColumn]) {
    1151511515                    numberTightened++;
     
    1388713887                                            //nRedundantDown++;
    1388813888#ifndef JJF_ONE
    13889                                             printf("%d redundant branch down with bounds %g, %g current upper %g solution %g dj %g\n",
    13890                                                    iColumn2, bounds[0], bounds[1], upper[iColumn2], solution[iColumn2], djValue);
     13889                                            COIN_DETAIL_PRINT(printf("%d redundant branch down with bounds %g, %g current upper %g solution %g dj %g\n",
     13890                                                                     iColumn2, bounds[0], bounds[1], upper[iColumn2], solution[iColumn2], djValue));
    1389113891#endif
    1389213892                                            if (bounds[0] == bounds[1] || zeroOne2 || (bounds[0] == lower[iColumn2] && false)) {
     
    1390013900                                                assert (newLower == lower[iColumn2]);
    1390113901                                            } else {
    13902                                                 printf("SKipping\n");
     13902                                              COIN_DETAIL_PRINT(printf("SKipping\n"));
    1390313903                                            }
    1390413904                                        } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2 && false) {
     
    1390813908                                                newLower = bounds1[0];
    1390913909                                                newUpper = bounds1[1];
    13910                                                 printf("setting bounds of %g and %g (column %d) on other branch for column %d\n",
    13911                                                        newLower, newUpper, iColumn1, iColumn2);
     13910                                                COIN_DETAIL_PRINT(printf("setting bounds of %g and %g (column %d) on other branch for column %d\n",
     13911                                                                         newLower, newUpper, iColumn1, iColumn2));
    1391213912                                                int infeasible = objectI->applyExtraBounds(iColumn1, newLower, newUpper, objectI->way());
    1391313913                                                if (infeasible) {
    13914                                                     printf("infeasa!\n");;
     13914                                                  COIN_DETAIL_PRINT(printf("infeasa!\n"));
    1391513915                                                    // get rid of node as far as branching
    1391613916                                                    nodeLook->setObjectiveValue(0.5*COIN_DBL_MAX);
     
    1393013930                                            //nRedundantUp++;
    1393113931#ifndef JJF_ONE
    13932                                             printf("%d redundant branch up with bounds %g, %g current lower %g solution %g dj %g\n",
    13933                                                    iColumn2, bounds[0], bounds[1], lower[iColumn2], solution[iColumn2], djValue);
     13932                                            COIN_DETAIL_PRINT(printf("%d redundant branch up with bounds %g, %g current lower %g solution %g dj %g\n",
     13933                                                                     iColumn2, bounds[0], bounds[1], lower[iColumn2], solution[iColumn2], djValue));
    1393413934#endif
    1393513935                                            if (bounds[0] == bounds[1] || zeroOne2 || (bounds[1] == upper[iColumn2] && false)) {
     
    1394313943                                                assert (newUpper == upper[iColumn2]);
    1394413944                                            } else {
    13945                                                 printf("SKipping\n");
     13945                                              COIN_DETAIL_PRINT(printf("SKipping\n"));
    1394613946                                            }
    1394713947                                        } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2 && false) {
     
    1395013950                                            newLower = bounds1[0];
    1395113951                                            newUpper = bounds1[1];
    13952                                             printf("setting bounds of %g and %g (column %d) on other branch for column %d\n",
    13953                                                    newLower, newUpper, iColumn1, iColumn2);
     13952                                            COIN_DETAIL_PRINT(printf("setting bounds of %g and %g (column %d) on other branch for column %d\n",
     13953                                                   newLower, newUpper, iColumn1, iColumn2));
    1395413954                                            int infeasible = objectI->applyExtraBounds(iColumn1, newLower, newUpper, objectI->way());
    1395513955                                            if (infeasible) {
    13956                                                 printf("infeasb!\n");;
     13956                                              COIN_DETAIL_PRINT(printf("infeasb!\n"));
    1395713957                                                // get rid of node as far as branching
    1395813958                                                nodeLook->setObjectiveValue(0.5*COIN_DBL_MAX);
     
    1430914309    } else {
    1431014310        // add cuts found to be infeasible (on bound)!
    14311         printf("found to be infeas! - branches left %d - cutoff %g\n", node->nodeInfo()->numberBranchesLeft(),
    14312                getCutoff());
     14311        COIN_DETAIL_PRINT(printf("found to be infeas! - branches left %d - cutoff %g\n", node->nodeInfo()->numberBranchesLeft(),
     14312               getCutoff()));
    1431314313        node->print();
    1431414314        //abort();
Note: See TracChangeset for help on using the changeset viewer.