Ignore:
Timestamp:
Sep 14, 2014 3:53:50 AM (5 years ago)
Author:
forrest
Message:

out fathomDone assert and fix debug compiler errors

Location:
trunk/Cbc/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src

  • trunk/Cbc/src/CbcModel.cpp

    r2070 r2073  
    38623862                // zap parent nodeInfo
    38633863#ifdef COIN_DEVELOP
    3864                 printf("zapping CbcNodeInfo %x\n", reinterpret_cast<int>(newNode->nodeInfo()->parent()));
     3864                printf("zapping CbcNodeInfo %x\n", newNode->nodeInfo()->parent());
    38653865#endif
    38663866                if (newNode->nodeInfo())
     
    76717671#endif
    76727672#endif   
    7673 #if COIN_DEVELOP>1
    7674     //if (!solver_->getIterationCount()&&solver_->isProvenOptimal())
    7675     //printf("zero iterations on first solve of branch\n");
    7676 #endif
    76777673    double lastObjective = solver_->getObjValue() * solver_->getObjSense();
    76787674    cut_obj[CUT_HISTORY-1] = lastObjective;
     
    1054410540            printf("%d cliques of average size %g found, %d P1, %d M1\n",
    1054510541                   numberCliques,
    10546                    (static_cast<double>(totalP1 + totalM1)) / (static_cast<double> numberCliques),
     10542                   (static_cast<double>(totalP1 + totalM1)) / (static_cast<double> (numberCliques)),
    1054710543                   totalP1, totalM1);
    1054810544        else
     
    1224712243#endif
    1224812244            if (!solver_->isProvenOptimal()) {
    12249 #if COIN_DEVELOP>1
     12245#if CBC_FEASIBILITY_INVESTIGATE
    1225012246                printf("checkSolution infeas! Retrying with primal.\n");
    1225112247#endif
     
    1226912265                    solver_->setWarmStart(slack);
    1227012266                    delete slack ;
    12271 #if COIN_DEVELOP>1
     12267#if CBC_FEASIBILITY_INVESTIGATE
    1227212268                    printf("checkSolution infeas! Retrying wihout basis and with primal.\n");
    1227312269#endif
     
    1228912285                    }
    1229012286#endif
    12291 #if COIN_DEVELOP>1
     12287#if CBC_FEASIBILITY_INVESTIGATE
    1229212288                    if (!solver_->isProvenOptimal()) {
    1229312289                        printf("checkSolution still infeas!\n");
     
    1232112317            double integerTolerance = getIntegerTolerance() ;
    1232212318#endif
    12323 #if COIN_DEVELOP>1
     12319#if CBC_FEASIBILITY_INVESTIGATE
    1232412320            const double * dj = solver_->getReducedCost();
    1232512321            const double * colLower = saveSolver->getColLower();
     
    1234112337                if (solver_->isInteger(iColumn)) {
    1234212338                    assert(fabs(value - solution[iColumn]) <= 100.0*integerTolerance) ;
    12343 #if COIN_DEVELOP>1
     12339#if CBC_FEASIBILITY_INVESTIGATE
    1234412340                    double value2 = floor(value + 0.5);
    1234512341                    if (dj[iColumn] < -1.0e-6) {
     
    1239212388                solution[iColumn] = value ;
    1239312389            }
    12394 #if COIN_DEVELOP>1
     12390#if CBC_FEASIBILITY_INVESTIGATE
    1239512391            printf("nAtLbNat %d,nAtUbNat %d,nAtLbNatZero %d,nAtUbNatZero %d,nAtLbFixed %d,nAtUbFixed %d,nAtOther %d,nAtOtherNat %d, useless %d\n",
    1239612392                   nAtLbNatural,
     
    1244912445                }
    1245012446                for (i = 0 ; i < numberRows ; i++) {
    12451 #ifdef CLP_INVESTIGATE
     12447#if CBC_FEASIBILITY_INVESTIGATE>1
    1245212448                    double inf;
    1245312449                    inf = rowLower[i] - rowActivity[i];
     
    1247212468                delete [] rowActivity ;
    1247312469                delete [] rowSum;
     12470#if CBC_FEASIBILITY_INVESTIGATE==0
    1247412471                if (handler_->logLevel()>2) {
     12472#endif
    1247512473                  if (largestInfeasibility > 10.0*primalTolerance)
    1247612474                    printf("BLargest infeasibility is %g - obj %g (%g)\n", largestInfeasibility,objValue,objectiveValue);
    1247712475                  else
    1247812476                    printf("BFeasible (%g) - obj %g %g\n", largestInfeasibility,objValue,objectiveValue);
     12477#if CBC_FEASIBILITY_INVESTIGATE==0
    1247912478                }
     12479#endif
    1248012480                //if (fabs(objValue-objectiveValue)>1.0e-7*fabs(objectiveValue)) {
    1248112481                //printf("Bad obj values\n");
    1248212482                objectiveValue = objValue;
    1248312483                //}
    12484 #if 1 //def CLP_INVESTIGATE
     12484#if CBC_FEASIBILITY_INVESTIGATE
    1248512485                if (largestInfeasibility > 10.0*primalTolerance)
    1248612486                    printf("XX largest infeasibility is %g\n", largestInfeasibility);
     
    1271512715        if (saveObjectiveValue + 1.0e-3 +1.0e-7*fabs(saveObjectiveValue)
    1271612716            < objectiveValue) {
    12717 #if COIN_DEVELOP>1
     12717#if CBC_FEASIBILITY_INVESTIGATE
    1271812718            printf("First try at solution had objective %.16g, rechecked as %.16g\n",
    1271912719                   saveObjectiveValue, objectiveValue);
     
    1272912729            double objectiveValue2 = saveObjectiveValue;
    1273012730            objectiveValue2 = checkSolution(cutoff, solution2, -1, objectiveValue2);
    12731 #if COIN_DEVELOP>1
     12731#if CBC_FEASIBILITY_INVESTIGATE
    1273212732            printf("Relaxed second try had objective of %.16g\n",
    1273312733                   objectiveValue2);
     
    1274112741                int iAway = -1;
    1274212742                double largestInfeasibility = tolerance;
    12743 #if COIN_DEVELOP>1
     12743#if CBC_FEASIBILITY_INVESTIGATE
    1274412744                int iInfeas = -1;
    1274512745#endif
     
    1275012750                    double value = solution2[i];
    1275112751                    if (value > columnUpper[i] + largestInfeasibility) {
    12752 #if COIN_DEVELOP>1
     12752#if CBC_FEASIBILITY_INVESTIGATE
    1275312753                        iInfeas = i;
    1275412754#endif
    1275512755                        largestInfeasibility = value - columnUpper[i];
    1275612756                    } else if (value < columnLower[i] - largestInfeasibility) {
    12757 #if COIN_DEVELOP>1
     12757#if CBC_FEASIBILITY_INVESTIGATE
    1275812758                        iInfeas = i;
    1275912759#endif
     
    1277412774                    }
    1277512775                }
    12776 #if COIN_DEVELOP>1
     12776#if CBC_FEASIBILITY_INVESTIGATE
    1277712777                if (iInfeas >= 0)
    1277812778                    printf("Largest infeasibility of %g on column %d - tolerance %g\n",
     
    1283812838            // But allow for rounding errors
    1283912839            if (dblParam_[CbcCutoffIncrement] == 1e-5) {
    12840 #if COIN_DEVELOP>5
     12840#if CBC_FEASIBILITY_INVESTIGATE
    1284112841                if (saveObjectiveValue + 1.0e-7 < bestObjective_)
    1284212842                    printf("First try at solution had objective %.16g, rechecked as %.16g\n",
     
    1490814908            // zap parent nodeInfo
    1490914909#ifdef COIN_DEVELOP
    14910             printf("zapping3 CbcNodeInfo %x\n", reinterpret_cast<int>(newNode->nodeInfo()->parent()));
     14910            printf("zapping3 CbcNodeInfo %x\n", newNode->nodeInfo()->parent());
    1491114911#endif
    1491214912            if (newNode->nodeInfo())
     
    1579815798            }
    1579915799#ifdef COIN_HAS_CLP
    15800             bool fathomDone = false;
    1580115800            OsiClpSolverInterface * clpSolver
    1580215801            = dynamic_cast<OsiClpSolverInterface *> (solver_);
     
    1597315972                                clpSolver->setWarmStart(NULL);
    1597415973                                // try and do solution
    15975                                 double value = simplex->objectiveValue() *
    15976                                                simplex->optimizationDirection();
     15974                                double value = simplex->objectiveValue();
    1597715975                                double * newSolution =
    1597815976                                    CoinCopyOfArray(simplex->primalColumnSolution(),
     
    1599115989                                clpSolver->setWarmStart(NULL);
    1599215990                                // try and do solution
    15993                                 double value = simplex->objectiveValue() *
    15994                                                simplex->optimizationDirection();
     15991                                double value = simplex->objectiveValue();
    1599515992                                double * newSolution =
    1599615993                                    CoinCopyOfArray(simplex->primalColumnSolution(),
    1599715994                                                    numberColumns);
    1599815995                                setBestSolution(CBC_STRONGSOL, value, newSolution) ;
     15996                                // in case of inaccuracy
     15997                                simplex->setObjectiveValue(CoinMax(bestObjective_,
     15998                                                                   simplex->objectiveValue()));
    1599915999                                delete [] newSolution;
    1600016000                            }
     
    1602616026                            }
    1602716027                            //printf("range of costs %g to %g\n",smallest,largest);
    16028                             // If value of objective borderline then may not be feasible
    16029                             double value = simplex->objectiveValue() * simplex->optimizationDirection();
    16030                             if (value - getCutoff() < -1.0e-1)
    16031                                 fathomDone = true;
    1603216028                        }
    1603316029                        simplex->setLogLevel(saveLevel);
     
    1610016096                            setBestSolution(CBC_STRONGSOL, value, newSolution) ;
    1610116097                            delete [] newSolution;
    16102                             fathomDone = true;
    16103                         } else {
    16104                             feasible = false;
    1610516098                        }
    1610616099#endif
     
    1611216105                int numberPasses = /*doCutsNow(1) ?*/ maximumCutPasses_ /*: 0*/;
    1611316106                feasible = solveWithCuts(cuts, numberPasses, node);
    16114                 if (fathomDone)
    16115                     assert (feasible);
    1611616107            }
    1611716108#else
Note: See TracChangeset for help on using the changeset viewer.