Changeset 1641 for trunk/Cbc/src


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

out some printf statements

Location:
trunk/Cbc/src
Files:
18 edited

Legend:

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

    r1573 r1641  
    435435            bestObject->way(bestWay);
    436436        } else {
    437             printf("debug\n");
     437          COIN_DETAIL_PRINT(printf("debug\n"));
    438438        }
    439439    }
  • trunk/Cbc/src/CbcCountRowCut.cpp

    r1573 r1641  
    8888        if (numberPointingToThis_ < change) {
    8989            assert(numberPointingToThis_ > 0);
    90             printf("negative cut count %d - %d\n", numberPointingToThis_, change);
     90            COIN_DETAIL_PRINT(printf("negative cut count %d - %d\n", numberPointingToThis_, change));
    9191            change = numberPointingToThis_;
    9292        }
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r1573 r1641  
    579579            }
    580580            if (nOdd)
    581                 printf("Cut generator %s produced %d cuts of which %d were modified\n",
    582                        generatorName_, numberRowCutsAfter - numberRowCutsBefore, nOdd);
     581                COIN_DETAIL_PRINT(printf("Cut generator %s produced %d cuts of which %d were modified\n",
     582                                         generatorName_, numberRowCutsAfter - numberRowCutsBefore, nOdd));
    583583        }
    584584        {
  • trunk/Cbc/src/CbcCutSubsetModifier.cpp

    r1573 r1641  
    9494        }
    9595    }
     96#ifdef COIN_DETAIL
    9697    if (!returnCode) {
    9798        const double * element = cut.row().getElements();
     
    102103        printf("<= %g\n", cut.ub());
    103104    }
     105#endif
    104106    //return 3;
    105107    return returnCode;
  • trunk/Cbc/src/CbcFathomDynamicProgramming.cpp

    r1573 r1641  
    435435    delete [] rhs;
    436436    if (allowableSize && size_ > allowableSize) {
    437         printf("Too large - need %d entries x 8 bytes\n", size_);
     437      COIN_DETAIL_PRINT(printf("Too large - need %d entries x 8 bytes\n", size_));
    438438        return -1; // too big
    439439    } else {
     
    484484        for (i = 0; i < numberColumns; i++) {
    485485            if (size_ > 10000000 && (i % 100) == 0)
    486                 printf("column %d\n", i);
     486              COIN_DETAIL_PRINT(printf("column %d\n", i));
    487487            double lowerValue = lower[i];
    488488            assert (lowerValue == floor(lowerValue));
  • trunk/Cbc/src/CbcFullNodeInfo.cpp

    r1573 r1641  
    163163{
    164164    if ((force && 1) == 0) {
    165         if (lower > lower_[iColumn])
    166             printf("%d odd lower going from %g to %g\n", iColumn, lower, lower_[iColumn]);
     165      if (lower > lower_[iColumn])
     166        COIN_DETAIL_PRINT(printf("%d odd lower going from %g to %g\n", iColumn, lower, lower_[iColumn]));
    167167        lower = lower_[iColumn];
    168168    } else {
     
    170170    }
    171171    if ((force && 2) == 0) {
    172         if (upper < upper_[iColumn])
    173             printf("%d odd upper going from %g to %g\n", iColumn, upper, upper_[iColumn]);
     172      if (upper < upper_[iColumn])
     173        COIN_DETAIL_PRINT(printf("%d odd upper going from %g to %g\n", iColumn, upper, upper_[iColumn]));
    174174        upper = upper_[iColumn];
    175175    } else {
  • trunk/Cbc/src/CbcHeuristic.cpp

    r1587 r1641  
    15221522    dist += subsetWeight * (numObjects_ - i + node->numObjects_ - j);
    15231523    countSubsetWeight += (numObjects_ - i + node->numObjects_ - j);
    1524     printf("subset = %i, overlap = %i, disjoint = %i\n", countSubsetWeight,
    1525            countOverlapWeight, countDisjointWeight);
     1524    COIN_DETAIL_PRINT(printf("subset = %i, overlap = %i, disjoint = %i\n", countSubsetWeight,
     1525                             countOverlapWeight, countDisjointWeight));
    15261526    return dist;
    15271527}
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r1613 r1641  
    886886            } else {
    887887                // bad solution - should not happen so debug if see message
    888                 printf("Local search got bad solution with %d infeasibilities summing to %g\n",
    889                        numberBad, sumBad);
     888                COIN_DETAIL_PRINT(printf("Local search got bad solution with %d infeasibilities summing to %g\n",
     889                                         numberBad, sumBad));
    890890            }
    891891        }
     
    10581058            memcpy(betterSolution, newSolver->getColSolution(),
    10591059                   numberColumns*sizeof(double));
    1060             printf("Naive fixing close to zero gave solution of %g\n", solutionValue);
     1060            COIN_DETAIL_PRINT(printf("Naive fixing close to zero gave solution of %g\n", solutionValue));
    10611061            cutoff = solValue - model_->getCutoffIncrement();
    10621062        }
     
    10951095                // try branch and bound
    10961096                double * newSolution = new double [numberColumns];
    1097                 printf("%d fixed after fixing costs\n", nFix);
     1097                COIN_DETAIL_PRINT(printf("%d fixed after fixing costs\n", nFix));
    10981098                int returnCode = smallBranchAndBound(newSolver,
    10991099                                                     numberNodes_, newSolution,
     
    11111111                    memcpy(betterSolution, newSolution,
    11121112                           numberColumns*sizeof(double));
    1113                     printf("Naive fixing zeros gave solution of %g\n", solutionValue);
     1113                    COIN_DETAIL_PRINT(printf("Naive fixing zeros gave solution of %g\n", solutionValue));
    11141114                    cutoff = solutionValue - model_->getCutoffIncrement();
    11151115                }
     
    11681168            // try branch and bound
    11691169            double * newSolution = new double [numberColumns];
    1170             printf("%d fixed after maximizing\n", nFix);
     1170            COIN_DETAIL_PRINT(printf("%d fixed after maximizing\n", nFix));
    11711171            int returnCode = smallBranchAndBound(newSolver,
    11721172                                                 numberNodes_, newSolution,
     
    11841184                memcpy(betterSolution, newSolution,
    11851185                       numberColumns*sizeof(double));
    1186                 printf("Naive maximizing gave solution of %g\n", solutionValue);
     1186                COIN_DETAIL_PRINT(printf("Naive maximizing gave solution of %g\n", solutionValue));
    11871187                cutoff = solutionValue - model_->getCutoffIncrement();
    11881188            }
  • trunk/Cbc/src/CbcHeuristicPivotAndFix.cpp

    r1573 r1641  
    397397                    }
    398398                }
    399                 printf("numFixed: %d\n", numFixed);
    400                 printf("fixThreshold: %f\n", fixThreshold);
    401                 printf("numInt: %d\n", numInt);
     399                COIN_DETAIL_PRINT(printf("numFixed: %d\n", numFixed));
     400                COIN_DETAIL_PRINT(printf("fixThreshold: %f\n", fixThreshold));
     401                COIN_DETAIL_PRINT(printf("numInt: %d\n", numInt));
    402402                double *newSolution = new double[numCols];
    403403                double newSolutionValue;
     
    415415                    for (int m = 0; m < numCols; m++)
    416416                        betterSolution[m] = newSolution[m];
    417                     printf("cutoff: %f\n", newSolutionValue);
    418                     printf("time: %.2lf\n", CoinCpuTime() - start);
     417                    COIN_DETAIL_PRINT(printf("cutoff: %f\n", newSolutionValue));
     418                    COIN_DETAIL_PRINT(printf("time: %.2lf\n", CoinCpuTime() - start));
    419419                }
    420420                didMiniBB = 1;
    421                 printf("returnCode: %d\n", returnCode);
     421                COIN_DETAIL_PRINT(printf("returnCode: %d\n", returnCode));
    422422
    423423                //Update sumReturnCode array
     
    435435                    cutoff = newSolutionValue;
    436436                    clpSolver->addRow(numCols, addRowIndex, originalObjCoeff, -COIN_DBL_MAX, cutoff);
    437                     printf("******************\n\n*****************\n");
     437                    COIN_DETAIL_PRINT(printf("******************\n\n*****************\n"));
    438438                }
    439439                break;
     
    497497        clpSolver->getModelPtr()->primal(1);
    498498        //        simplex->setMaximumIterations(100000);
     499#ifdef COIN_DETAIL
    499500        printf("cutoff: %f\n", cutoff);
    500501        printf("time: %.2f\n", CoinCpuTime() - start);
     
    504505        printf("numInt: %d\n", numInt);
    505506        printf("\n---------------------------------------------------------------- %d\n", i);
     507#endif
    506508
    507509        //temp:
     
    510512    }
    511513
    512     printf("Best Feasible Found: %f\n", cutoff);
    513     printf("Total time: %.2f\n", CoinCpuTime() - start);
     514    COIN_DETAIL_PRINT(printf("Best Feasible Found: %f\n", cutoff));
     515    COIN_DETAIL_PRINT(printf("Total time: %.2f\n", CoinCpuTime() - start));
    514516
    515517    if (numFeasibles == 0) {
  • trunk/Cbc/src/CbcHeuristicRENS.cpp

    r1591 r1641  
    642642          }
    643643          if (n>1)
    644             printf("Too many SOS entries (%d) for column %d\n",
    645                    n,iColumn);
     644            COIN_DETAIL_PRINT(printf("Too many SOS entries (%d) for column %d\n",
     645                                     n,iColumn));
    646646          if (sum) {
    647647            assert (iSOS>=0);
  • 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();
  • trunk/Cbc/src/CbcNode.cpp

    r1626 r1641  
    25682568                        }
    25692569                        if (CoinMax(downPenalty, upPenalty) > gap) {
    2570                             printf("gap %g object %d has down range %g, up %g\n",
    2571                                    gap, i, downPenalty, upPenalty);
     2570                            COIN_DETAIL_PRINT(printf("gap %g object %d has down range %g, up %g\n",
     2571                                                     gap, i, downPenalty, upPenalty));
    25722572                            //sort[j] -= 1.0e50; // make more likely to be chosen
    25732573                            int number;
     
    25902590                        }
    25912591                        if (!numberNodes)
    2592                             printf("%d pen down ps %g -> %g up ps %g -> %g\n",
    2593                                    iObject, downPenalty, downPenalty, upPenalty, upPenalty);
     2592                            COIN_DETAIL_PRINT(printf("%d pen down ps %g -> %g up ps %g -> %g\n",
     2593                                                     iObject, downPenalty, downPenalty, upPenalty, upPenalty));
    25942594                    }
    25952595                    if (numberFixed && problemFeasible) {
     
    26032603                    }
    26042604                    if (!problemFeasible) {
    2605                         fprintf(stdout, "both ways infeas on ranging - code needed\n");
     2605                      COIN_DETAIL_PRINT(fprintf(stdout, "both ways infeas on ranging - code needed\n"));
    26062606                        anyAction = -2;
    26072607                        if (!choiceObject) {
     
    34643464        if (numberUnfinished*10 > numberStrongDone + 1 ||
    34653465                !numberStrongInfeasible) {
    3466             printf("going to strategy 2\n");
     3466          COIN_DETAIL_PRINT(printf("going to strategy 2\n"));
    34673467            // Weaken
    34683468            model->setNumberStrong(2);
     
    38803880                // neither side feasible
    38813881                anyAction = -2;
    3882                 printf("Both infeasible for choice %d sequence %d\n", i,
    3883                        model->object(choice.objectNumber)->columnNumber());
     3882                COIN_DETAIL_PRINT(printf("Both infeasible for choice %d sequence %d\n", i,
     3883                                         model->object(choice.objectNumber)->columnNumber()));
    38843884                delete ws;
    38853885                ws = NULL;
     
    38973897        //     choice.downMovement,choice.upMovement,value);
    38983898    }
    3899     printf("Best possible solution %g, can fix more if solution of %g found - looked at %d variables in %d iterations\n",
    3900            objMin, objMax, iDo, model->numberAnalyzeIterations() - numberIterationsAllowed);
     3899    COIN_DETAIL_PRINT(printf("Best possible solution %g, can fix more if solution of %g found - looked at %d variables in %d iterations\n",
     3900                             objMin, objMax, iDo, model->numberAnalyzeIterations() - numberIterationsAllowed));
    39013901    model->setNumberAnalyzeIterations(numberIterationsAllowed);
    39023902    // Delete the snapshot
     
    43394339            bool gotSol = model->feasibleSolution(numInf, numInf2);
    43404340            if (!gotSol) {
    4341                 printf("numinf %d\n", numInf);
     4341              COIN_DETAIL_PRINT(printf("numinf %d\n", numInf));
    43424342                double * sol = simplex->primalColumnSolution();
    43434343                for (int i = 0; i < numberColumns; i++) {
     
    43454345                        double value = floor(sol[i] + 0.5);
    43464346                        if (fabs(value - sol[i]) > 1.0e-7) {
    4347                             printf("%d value %g\n", i, sol[i]);
     4347                          COIN_DETAIL_PRINT(printf("%d value %g\n", i, sol[i]));
    43484348                            if (fabs(value - sol[i]) < 1.0e-3) {
    43494349                                sol[i] = value;
  • trunk/Cbc/src/CbcPartialNodeInfo.cpp

    r1573 r1641  
    212212                if ((force&1) == 0) {
    213213                    if (lower > newBounds_[i])
    214                         printf("%d odd lower going from %g to %g\n", iColumn, lower, newBounds_[i]);
     214                      COIN_DETAIL_PRINT(printf("%d odd lower going from %g to %g\n", iColumn, lower, newBounds_[i]));
    215215                    lower = newBounds_[i];
    216216                } else {
     
    224224                if ((force&2) == 0) {
    225225                    if (upper < newBounds_[i])
    226                         printf("%d odd upper going from %g to %g\n", iColumn, upper, newBounds_[i]);
     226                      COIN_DETAIL_PRINT(printf("%d odd upper going from %g to %g\n", iColumn, upper, newBounds_[i]));
    227227                    upper = newBounds_[i];
    228228                } else {
  • trunk/Cbc/src/CbcSOS.cpp

    r1573 r1641  
    473473    }
    474474    if (n2 < numberMembers_) {
    475         //printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2);
     475      COIN_DETAIL_PRINT(printf("** SOS number of members reduced from %d to %d!\n",numberMembers_,n2));
    476476        numberMembers_ = n2;
    477477    }
  • trunk/Cbc/src/CbcSolverHeuristics.cpp

    r1573 r1641  
    127127            double time1 = CoinCpuTime();
    128128            originalClpSolver->initialSolve();
    129             printf("first solve took %g seconds\n", CoinCpuTime() - time1);
     129            COIN_DETAIL_PRINT(printf("first solve took %g seconds\n", CoinCpuTime() - time1));
    130130            double * columnLower = originalLpSolver->columnLower() ;
    131131            double * columnUpper = originalLpSolver->columnUpper() ;
     
    154154                }
    155155            }
    156             printf("%d artificials fixed, %d left as in solution\n", nFix, nArt);
     156            COIN_DETAIL_PRINT(printf("%d artificials fixed, %d left as in solution\n", nFix, nArt));
    157157            lpSolver = pinfo.presolvedModel(*originalLpSolver, 1.0e-8, true, 10);
    158158            if (!lpSolver || doAction == 2) {
     
    583583                }
    584584            }
     585#ifdef COIN_DETAIL
    585586            if (numberLayered) {
    586                 printf("%d (%d integer) at priority %d\n", numberLayered, numberInteger, 1 + (jLayer / 100));
     587                printf("%d (%d integer) at priority %d\n", numberLayered, numberInteger, 1 + (jLayer / 100));
    587588                char buffer[50];
    588589                for (int i = 1; i < nCheck; i++) {
     
    598599                }
    599600            }
     601#endif
    600602        }
    601603    }
     
    746748                    jLayer += 100;
    747749                }
    748                 printf("This fixes %d variables in lower priorities\n", nTotalFixed);
     750                COIN_DETAIL_PRINT(printf("This fixes %d variables in lower priorities\n", nTotalFixed));
    749751                break;
    750752            }
     
    795797            }
    796798            if (toZero || toOne)
    797                 printf("%d at 0 fixed and %d at one fixed\n", toZero, toOne);
    798             printf("%d variables free, %d fixed to 0, %d to 1 - smallest %g, largest %g\n",
    799                    numberFree, atZero, atOne, smallest, largest);
     799              COIN_DETAIL_PRINT(printf("%d at 0 fixed and %d at one fixed\n", toZero, toOne));
     800            COIN_DETAIL_PRINT(printf("%d variables free, %d fixed to 0, %d to 1 - smallest %g, largest %g\n",
     801                                     numberFree, atZero, atOne, smallest, largest));
    800802            if (numberGreater && !iPass)
    801                 printf("%d variables have value > 1.0\n", numberGreater);
     803              COIN_DETAIL_PRINT(printf("%d variables have value > 1.0\n", numberGreater));
    802804            //skipZero2=0; // leave 0 fixing
    803805            int jLayer = 0;
     
    830832                jLayer += 100;
    831833            }
    832             printf("This fixes %d variables in lower priorities\n", nTotalFixed);
     834            COIN_DETAIL_PRINT(printf("This fixes %d variables in lower priorities\n", nTotalFixed));
    833835            if (iLargest < 0 || numberFree <= leaveIntFree)
    834836                break;
     
    868870            crunchIt(lpSolver);
    869871            double moveObj = lpSolver->objectiveValue() - saveObj;
    870             printf("movement %s was %g costing %g\n",
    871                    (way == -1) ? "down" : "up", movement, moveObj);
     872            COIN_DETAIL_PRINT(printf("movement %s was %g costing %g\n",
     873                                     (way == -1) ? "down" : "up", movement, moveObj));
    872874            if (way == -1 && (moveObj >= maxCostUp || lpSolver->status())) {
    873875                // go up
     
    897899        }
    898900        lpSolver->dual();
    899         printf("Fixing took %g seconds\n", CoinCpuTime() - time1);
     901        COIN_DETAIL_PRINT(printf("Fixing took %g seconds\n", CoinCpuTime() - time1));
    900902        columnLower = lpSolver->columnLower();
    901903        columnUpper = lpSolver->columnUpper();
     
    10091011                }
    10101012            }
    1011             printf("%d fixed %d orig 0 %d 1\n", nFixed, nFixed0, nFixed1);
     1013            COIN_DETAIL_PRINT(printf("%d fixed %d orig 0 %d 1\n", nFixed, nFixed0, nFixed1));
    10121014            int jLayer = 0;
    10131015            nFixed = -1;
     
    10491051                }
    10501052            }
    1051             printf("This fixes %d variables in lower priorities - total %d (%d integer) - all target %d, int target %d\n",
    1052                    nTotalFixed, nFixed, nFixedI, static_cast<int>(fractionFixed*numberColumns), static_cast<int> (fractionIntFixed*numberInteger));
     1053            COIN_DETAIL_PRINT(printf("This fixes %d variables in lower priorities - total %d (%d integer) - all target %d, int target %d\n",
     1054                                     nTotalFixed, nFixed, nFixedI, static_cast<int>(fractionFixed*numberColumns), static_cast<int> (fractionIntFixed*numberInteger)));
    10531055            int nBad = 0;
    10541056            int nRelax = 0;
     
    10561058                if (lo[iColumn] < columnLower[iColumn] ||
    10571059                        up[iColumn] > columnUpper[iColumn]) {
    1058                     printf("bad %d old %g %g, new %g %g\n", iColumn, lo[iColumn], up[iColumn],
    1059                            columnLower[iColumn], columnUpper[iColumn]);
     1060                    COIN_DETAIL_PRINT(printf("bad %d old %g %g, new %g %g\n", iColumn, lo[iColumn], up[iColumn],
     1061                                             columnLower[iColumn], columnUpper[iColumn]));
    10601062                    nBad++;
    10611063                }
     
    10651067                }
    10661068            }
    1067             printf("%d relaxed\n", nRelax);
     1069            COIN_DETAIL_PRINT(printf("%d relaxed\n", nRelax));
    10681070            if (iRelax > 20 && nRelax == chunk)
    10691071                nRelax = 0;
     
    11281130            doAction++;
    11291131    }
    1130     printf("%d fixed by vub preprocessing\n", doAction);
     1132    COIN_DETAIL_PRINT(printf("%d fixed by vub preprocessing\n", doAction));
    11311133    if (originalColumns) {
    11321134        originalLpSolver->initialSolve();
  • trunk/Cbc/src/CbcStrategy.cpp

    r1582 r1641  
    421421            }
    422422            if (!numberNon && numberClose) {
    423                 printf("Tidying %d multiples of 0.01, %d close\n",
    424                        numberInt, numberClose);
     423                COIN_DETAIL_PRINT(printf("Tidying %d multiples of 0.01, %d close\n",
     424                                         numberInt, numberClose));
    425425                for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    426426                    for (int j = columnStart[iColumn];
  • trunk/Cbc/src/CbcSubProblem.cpp

    r1573 r1641  
    219219            }
    220220        }
     221#ifdef CBC_PRINT2
    221222        if (nSame && (nSame < numberChangedBounds_ || (what&3) != 3))
    222223            printf("%d changes out of %d redundant %d\n",
     
    225226            printf("%d good changes %d\n",
    226227                   numberChangedBounds_, what);
     228#endif
    227229    }
    228230#ifdef JJF_ZERO
  • trunk/Cbc/src/CbcTreeLocal.cpp

    r1573 r1641  
    125125        typeCuts_ = 1; // may as well so we don't have to deal with refine
    126126    if (!number01 && !typeCuts_) {
    127         if (model_->messageHandler()->logLevel() > 0)
     127        if (model_->messageHandler()->logLevel() > 1)
    128128            printf("** No 0-1 variables and local search only on 0-1 - switching off\n");
    129129        typeCuts_ = -1;
    130130    } else {
    131         if (model_->messageHandler()->logLevel() > 0) {
     131        if (model_->messageHandler()->logLevel() > 1) {
    132132            std::string type;
    133133            if (all01) {
     
    348348        smallestD = CoinMin(smallestD, dd);
    349349    }
    350     if (model_->messageHandler()->logLevel() > 0) {
     350    if (model_->messageHandler()->logLevel() > 1) {
    351351        printf("smallest %d, largest %d, top %d\n", smallest, largest,
    352352               nodes_.front()->nodeInfo()->nodeNumber());
     
    370370            // we came in with solution
    371371            model_->globalCuts()->insert(cut_);
    372             if (model_->messageHandler()->logLevel() > 0)
     372            if (model_->messageHandler()->logLevel() > 1)
    373373                printf("initial cut - rhs %g %g\n",
    374374                       cut_.lb(), cut_.ub());
     
    443443
    444444    double increment = model_->getDblParam(CbcModel::CbcCutoffIncrement) ;
    445     if (model_->messageHandler()->logLevel() > 0)
     445    if (model_->messageHandler()->logLevel() > 1)
    446446        printf("local state %d after %d nodes and %d seconds, new solution %g, best solution %g, k was %g\n",
    447447               state,
     
    490490                    typeCuts_ = -1; // make sure can't start again
    491491                model_->setCutoff(bestCutoff_);
    492                 if (model_->messageHandler()->logLevel() > 0)
     492                if (model_->messageHandler()->logLevel() > 1)
    493493                    printf("Exiting local search with current set of cuts\n");
    494494                rhs_ = 1.0e100;
     
    621621            lastTry = true;
    622622            model_->setCutoff(bestCutoff_);
    623             if (model_->messageHandler()->logLevel() > 0)
     623            if (model_->messageHandler()->logLevel() > 1)
    624624                printf("Exiting local search with current set of cuts\n");
    625625            rhs_ = 1.0e100;
     
    638638            int n = global->sizeRowCuts();
    639639            OsiRowCut * rowCut = global->rowCutPtr(n - 1);
    640             if (model_->messageHandler()->logLevel() > 0)
     640            if (model_->messageHandler()->logLevel() > 1)
    641641                printf("inserting cut - now %d cuts, rhs %g %g, cutspace %g, diversification %d\n",
    642642                       n, rowCut->lb(), rowCut->ub(), rhs_, diversification_);
     
    773773        }
    774774        if (maxValue < rhs - primalTolerance) {
    775             if (model_->messageHandler()->logLevel() > 0)
     775            if (model_->messageHandler()->logLevel() > 1)
    776776                printf("slack cut\n");
    777777            goodSolution = 1;
     
    781781        rowCut.setUb(rhs);
    782782        rowCut.setGloballyValid();
    783         if (model_->messageHandler()->logLevel() > 0)
     783        if (model_->messageHandler()->logLevel() > 1)
    784784            printf("Cut size: %i Cut rhs: %g\n", cut.getNumElements(), rhs);
    785785#ifdef CBC_DEBUG
     
    797797        return goodSolution;
    798798    } else {
    799         if (model_->messageHandler()->logLevel() > 0)
     799        if (model_->messageHandler()->logLevel() > 1)
    800800            printf("Not a good solution\n");
    801801        return -1;
     
    834834    }
    835835    // replace by other way
    836     if (model_->messageHandler()->logLevel() > 0)
     836    if (model_->messageHandler()->logLevel() > 1)
    837837        printf("reverseCut - changing cut %d out of %d, old rhs %g %g ",
    838838               i, n, rowCut->lb(), rowCut->ub());
    839839    rowCut->setLb(rowCut->ub() + smallest - bias);
    840840    rowCut->setUb(COIN_DBL_MAX);
    841     if (model_->messageHandler()->logLevel() > 0)
     841    if (model_->messageHandler()->logLevel() > 1)
    842842        printf("new rhs %g %g, bias %g smallest %g ",
    843843               rowCut->lb(), rowCut->ub(), bias, smallest);
     
    865865    assert (i < n);
    866866    // delete last cut
    867     if (model_->messageHandler()->logLevel() > 0)
     867    if (model_->messageHandler()->logLevel() > 1)
    868868        printf("deleteCut - deleting cut %d out of %d, rhs %g %g\n",
    869869               i, n, rowCut->lb(), rowCut->ub());
     
    999999        typeCuts_ = 1; // may as well so we don't have to deal with refine
    10001000    if (!number01 && !typeCuts_) {
    1001         if (model_->messageHandler()->logLevel() > 0)
     1001        if (model_->messageHandler()->logLevel() > 1)
    10021002            printf("** No 0-1 variables and local search only on 0-1 - switching off\n");
    10031003        typeCuts_ = -1;
    10041004    } else {
    1005         if (model_->messageHandler()->logLevel() > 0) {
     1005        if (model_->messageHandler()->logLevel() > 1) {
    10061006            std::string type;
    10071007            if (all01) {
     
    12221222        smallestD = CoinMin(smallestD, dd);
    12231223    }
    1224     if (model_->messageHandler()->logLevel() > 0) {
     1224    if (model_->messageHandler()->logLevel() > 1) {
    12251225        printf("smallest %d, largest %d, top %d\n", smallest, largest,
    12261226               nodes_.front()->nodeInfo()->nodeNumber());
     
    12441244            // we came in with solution
    12451245            model_->globalCuts()->insert(cut_);
    1246             if (model_->messageHandler()->logLevel() > 0)
     1246            if (model_->messageHandler()->logLevel() > 1)
    12471247                printf("initial cut - rhs %g %g\n",
    12481248                       cut_.lb(), cut_.ub());
     
    13171317
    13181318    double increment = model_->getDblParam(CbcModel::CbcCutoffIncrement) ;
    1319     if (model_->messageHandler()->logLevel() > 0)
     1319    if (model_->messageHandler()->logLevel() > 1)
    13201320        printf("local state %d after %d nodes and %d seconds, new solution %g, best solution %g, k was %g\n",
    13211321               state,
     
    13641364                    typeCuts_ = -1; // make sure can't start again
    13651365                model_->setCutoff(bestCutoff_);
    1366                 if (model_->messageHandler()->logLevel() > 0)
     1366                if (model_->messageHandler()->logLevel() > 1)
    13671367                    printf("Exiting local search with current set of cuts\n");
    13681368                rhs_ = 1.0e100;
     
    14951495            lastTry = true;
    14961496            model_->setCutoff(bestCutoff_);
    1497             if (model_->messageHandler()->logLevel() > 0)
     1497            if (model_->messageHandler()->logLevel() > 1)
    14981498                printf("Exiting local search with current set of cuts\n");
    14991499            rhs_ = 1.0e100;
     
    15121512            int n = global->sizeRowCuts();
    15131513            OsiRowCut * rowCut = global->rowCutPtr(n - 1);
    1514             if (model_->messageHandler()->logLevel() > 0)
     1514            if (model_->messageHandler()->logLevel() > 1)
    15151515                printf("inserting cut - now %d cuts, rhs %g %g, cutspace %g, diversification %d\n",
    15161516                       n, rowCut->lb(), rowCut->ub(), rhs_, diversification_);
     
    15221522            for (int i = 0; i < n; i++) {
    15231523                rowCut = global->rowCutPtr(i);
    1524                 if (model_->messageHandler()->logLevel() > 0)
     1524                if (model_->messageHandler()->logLevel() > 1)
    15251525                    printf("%d - rhs %g %g\n",
    15261526                           i, rowCut->lb(), rowCut->ub());
     
    16381638        }
    16391639        if (maxValue < rhs - primalTolerance) {
    1640             if (model_->messageHandler()->logLevel() > 0)
     1640            if (model_->messageHandler()->logLevel() > 1)
    16411641                printf("slack cut\n");
    16421642            goodSolution = 1;
     
    16461646        rowCut.setUb(rhs);
    16471647        rowCut.setGloballyValid();
    1648         if (model_->messageHandler()->logLevel() > 0)
     1648        if (model_->messageHandler()->logLevel() > 1)
    16491649            printf("Cut size: %i Cut rhs: %g\n", cut.getNumElements(), rhs);
    16501650#ifdef CBC_DEBUG
     
    16621662        return goodSolution;
    16631663    } else {
    1664         if (model_->messageHandler()->logLevel() > 0)
     1664        if (model_->messageHandler()->logLevel() > 1)
    16651665            printf("Not a good solution\n");
    16661666        return -1;
     
    16991699    }
    17001700    // replace by other way
    1701     if (model_->messageHandler()->logLevel() > 0)
     1701    if (model_->messageHandler()->logLevel() > 1)
    17021702        printf("reverseCut - changing cut %d out of %d, old rhs %g %g ",
    17031703               i, n, rowCut->lb(), rowCut->ub());
    17041704    rowCut->setLb(rowCut->ub() + smallest - bias);
    17051705    rowCut->setUb(COIN_DBL_MAX);
    1706     if (model_->messageHandler()->logLevel() > 0)
     1706    if (model_->messageHandler()->logLevel() > 1)
    17071707        printf("new rhs %g %g, bias %g smallest %g ",
    17081708               rowCut->lb(), rowCut->ub(), bias, smallest);
     
    17301730    assert (i < n);
    17311731    // delete last cut
    1732     if (model_->messageHandler()->logLevel() > 0)
     1732    if (model_->messageHandler()->logLevel() > 1)
    17331733        printf("deleteCut - deleting cut %d out of %d, rhs %g %g\n",
    17341734               i, n, rowCut->lb(), rowCut->ub());
Note: See TracChangeset for help on using the changeset viewer.