Ignore:
Timestamp:
Jun 19, 2011 1:23:14 PM (8 years ago)
Author:
stefan
Message:

sync with trunk rev1674

Location:
stable/2.7
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • stable/2.7

    • Property svn:externals
      •  

        old new  
        1 BuildTools  https://projects.coin-or.org/svn/BuildTools/stable/0.7
        2 ThirdParty/ASL  https://projects.coin-or.org/svn/BuildTools/ThirdParty/ASL/stable/1.2
        3 ThirdParty/Blas  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.2
        4 ThirdParty/Lapack  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.3
        5 ThirdParty/Glpk  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Glpk/stable/1.8
        6 Data/Sample  https://projects.coin-or.org/svn/Data/Sample/stable/1.2
        7 CoinUtils  https://projects.coin-or.org/svn/CoinUtils/stable/2.8/CoinUtils
        8 Cgl  https://projects.coin-or.org/svn/Cgl/stable/0.57/Cgl
        9 Clp  https://projects.coin-or.org/svn/Clp/stable/1.14/Clp
        10 Osi  https://projects.coin-or.org/svn/Osi/stable/0.105/Osi
         1BuildTools        https://projects.coin-or.org/svn/BuildTools/stable/0.7
         2ThirdParty/ASL    https://projects.coin-or.org/svn/BuildTools/ThirdParty/ASL/stable/1.2
         3ThirdParty/Blas   https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.2
         4ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.3
         5ThirdParty/Glpk   https://projects.coin-or.org/svn/BuildTools/ThirdParty/Glpk/stable/1.8
         6ThirdParty/Metis  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Metis/stable/1.2
         7ThirdParty/Mumps  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Mumps/stable/1.4
         8Data/Sample       https://projects.coin-or.org/svn/Data/Sample/stable/1.2
         9Data/miplib3      https://projects.coin-or.org/svn/Data/miplib3/stable/1.2
         10CoinUtils         https://projects.coin-or.org/svn/CoinUtils/stable/2.8/CoinUtils
         11Cgl               https://projects.coin-or.org/svn/Cgl/stable/0.57/Cgl
         12Clp               https://projects.coin-or.org/svn/Clp/stable/1.14/Clp
         13Osi               https://projects.coin-or.org/svn/Osi/stable/0.105/Osi
    • Property svn:mergeinfo changed
      /trunk (added)merged: 1578,​1582-1587,​1589-1600,​1603-1614,​1620-1626,​1631-1633,​1635-1636,​1638-1646,​1650-1652,​1654-1658,​1660-1663,​1665-1671,​1673-1674
  • stable/2.7/Cbc

  • stable/2.7/Cbc/src/CbcNode.cpp

    r1659 r1675  
    877877        }
    878878        // If we have hit max time don't do strong branching
    879         bool hitMaxTime = ( CoinCpuTime() - model->getDblParam(CbcModel::CbcStartSeconds) >
     879        bool hitMaxTime = (model->getCurrentSeconds() >
    880880                            model->getDblParam(CbcModel::CbcMaximumSeconds));
    881881        // also give up if we are looping round too much
     
    13461346                    }
    13471347                }
    1348                 bool hitMaxTime = ( CoinCpuTime() - model->getDblParam(CbcModel::CbcStartSeconds) >
     1348                bool hitMaxTime = (model->getCurrentSeconds() >
    13491349                                    model->getDblParam(CbcModel::CbcMaximumSeconds));
    13501350                if (hitMaxTime) {
     
    22532253                // may just need resolve
    22542254                model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    2255                 //double newObjValue = solver->getObjSense()*solver->getObjValue();
    2256                 //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     2255                double newObjValue = solver->getObjSense()*solver->getObjValue();
     2256                objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    22572257                if (!solver->isProvenOptimal()) {
    22582258                    // infeasible
     
    23762376                    solver->setHintParam(OsiDoDualInResolve, false, OsiHintDo) ;
    23772377                    model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    2378                     //double newObjValue = solver->getObjSense()*solver->getObjValue();
    2379                     //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     2378                    double newObjValue = solver->getObjSense()*solver->getObjValue();
     2379                    objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    23802380                    solver->setHintParam(OsiDoDualInResolve, takeHint, strength) ;
    23812381                    if (!solver->isProvenOptimal()) {
     
    24452445        assert (bestChoice >= 0);
    24462446        // If we have hit max time don't do strong branching
    2447         bool hitMaxTime = ( CoinCpuTime() - model->getDblParam(CbcModel::CbcStartSeconds) >
     2447        bool hitMaxTime = (model->getCurrentSeconds() >
    24482448                            model->getDblParam(CbcModel::CbcMaximumSeconds));
    24492449        // also give up if we are looping round too much
     
    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) {
     
    25972597                        solver->unmarkHotStart();
    25982598                        model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    2599                         //double newObjValue = solver->getObjSense()*solver->getObjValue();
    2600                         //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     2599                        double newObjValue = solver->getObjSense()*solver->getObjValue();
     2600                        objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    26012601                        solver->markHotStart();
    26022602                        problemFeasible = solver->isProvenOptimal();
    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) {
     
    28002800                        doneHotStart = true;
    28012801                        solver->markHotStart();
     2802                        if (!solver->isProvenOptimal()) {
     2803                          skipAll=-2;
     2804                          canSkip = true;
     2805                        }
    28022806                        xMark++;
    28032807                    }
     2808                }
     2809                if (!canSkip) {
    28042810                    numberTest--;
    28052811                    // just do a few
     
    28612867                            numberStrongInfeasible++;
    28622868                        } else {
    2863                             //#define TIGHTEN_BOUNDS
    2864 #ifdef TIGHTEN_BOUNDS
     2869#define CBCNODE_TIGHTEN_BOUNDS
     2870#ifdef CBCNODE_TIGHTEN_BOUNDS
    28652871                            // Can we tighten bounds?
    28662872                            if (iColumn < numberColumns && cutoff < 1.0e20
     
    28972903                                    model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    28982904                                    newObjectiveValue = solver->getObjSense() * solver->getObjValue();
    2899                                     //objectiveValue_ = CoinMax(objectiveValue_,newObjectiveValue);
     2905                                    objectiveValue_ = CoinMax(objectiveValue_,newObjectiveValue);
    29002906                                    objectiveChange = CoinMax(newObjectiveValue  - objectiveValue_, 0.0);
    29012907                                    model->feasibleSolution(choice.numIntInfeasDown,
     
    29312937                        needHotStartUpdate = false;
    29322938                        model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    2933                         //double newObjValue = solver->getObjSense()*solver->getObjValue();
    2934                         //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     2939                        double newObjValue = solver->getObjSense()*solver->getObjValue();
     2940                        objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    29352941                        //we may again have an integer feasible solution
    29362942                        int numberIntegerInfeasibilities;
     
    29512957                                                   solver->getColSolution()) ;
    29522958                            model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    2953                             //double newObjValue = solver->getObjSense()*solver->getObjValue();
    2954                             //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     2959                            double newObjValue = solver->getObjSense()*solver->getObjValue();
     2960                            objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    29552961                            cutoff = model->getCutoff();
    29562962                        }
     
    30083014                            numberStrongInfeasible++;
    30093015                        } else {
    3010 #ifdef TIGHTEN_BOUNDS
     3016#ifdef CBCNODE_TIGHTEN_BOUNDS
    30113017                            // Can we tighten bounds?
    30123018                            if (iColumn < numberColumns && cutoff < 1.0e20
     
    30583064                                    model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    30593065                                    newObjectiveValue = solver->getObjSense() * solver->getObjValue();
    3060                                     //objectiveValue_ = CoinMax(objectiveValue_,newObjectiveValue);
     3066                                    objectiveValue_ = CoinMax(objectiveValue_,newObjectiveValue);
    30613067                                    objectiveChange = CoinMax(newObjectiveValue  - objectiveValue_, 0.0);
    30623068                                    model->feasibleSolution(choice.numIntInfeasDown,
     
    30923098                        needHotStartUpdate = false;
    30933099                        model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    3094                         //double newObjValue = solver->getObjSense()*solver->getObjValue();
    3095                         //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     3100                        double newObjValue = solver->getObjSense()*solver->getObjValue();
     3101                        objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    30963102                        //we may again have an integer feasible solution
    30973103                        int numberIntegerInfeasibilities;
     
    31063112                                                   solver->getColSolution()) ;
    31073113                            model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    3108                             //double newObjValue = solver->getObjSense()*solver->getObjValue();
    3109                             //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     3114                            double newObjValue = solver->getObjSense()*solver->getObjValue();
     3115                            objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    31103116                            cutoff = model->getCutoff();
    31113117                        }
     
    32513257                        solver->unmarkHotStart();
    32523258                        model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    3253                         //double newObjValue = solver->getObjSense()*solver->getObjValue();
    3254                         //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     3259                        double newObjValue = solver->getObjSense()*solver->getObjValue();
     3260                        objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    32553261                        solver->markHotStart();
    32563262                        // may be infeasible (if other way stopped on iterations)
    3257                         if (!solver->isProvenOptimal()) {
     3263                        if (!solver->isProvenOptimal()||solver->isDualObjectiveLimitReached()) {
    32583264                            // neither side feasible
    32593265                            anyAction = -2;
     
    32933299                        solver->unmarkHotStart();
    32943300                        model->resolve(NULL, 11, saveSolution, saveLower, saveUpper);
    3295                         //double newObjValue = solver->getObjSense()*solver->getObjValue();
    3296                         //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     3301                        double newObjValue = solver->getObjSense()*solver->getObjValue();
     3302                        objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    32973303                        solver->markHotStart();
    32983304                        // may be infeasible (if other way stopped on iterations)
    3299                         if (!solver->isProvenOptimal()) {
     3305                        if (!solver->isProvenOptimal()||solver->isDualObjectiveLimitReached()) {
    33003306                            // neither side feasible
    33013307                            anyAction = -2;
     
    33213327                }
    33223328                // Check max time
    3323                 hitMaxTime = ( CoinCpuTime() - model->getDblParam(CbcModel::CbcStartSeconds) >
     3329                hitMaxTime = (model->getCurrentSeconds() >
    33243330                               model->getDblParam(CbcModel::CbcMaximumSeconds));
    33253331                if (hitMaxTime) {
     
    33773383                    solver->setHintParam(OsiDoInBranchAndCut, true, OsiHintDo, &easy) ;
    33783384                    model->resolve(NULL, 11, saveSolution, saveLower, saveUpper) ;
    3379                     //double newObjValue = solver->getObjSense()*solver->getObjValue();
    3380                     //objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
     3385                    double newObjValue = solver->getObjSense()*solver->getObjValue();
     3386                    objectiveValue_ = CoinMax(objectiveValue_,newObjValue);
    33813387                    solver->setHintParam(OsiDoInBranchAndCut, true, OsiHintDo, NULL) ;
    33823388                    feasible = solver->isProvenOptimal();
    33833389                    if (feasible) {
    33843390                        anyAction = 0;
    3385                         // See if candidate still possible
    3386                         if (branch_) {
    3387                             const OsiObject * object = model->object(bestChoice);
    3388                             int preferredWay;
    3389                             double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    3390                             if (!infeasibility) {
    3391                                 // take out
    3392                                 delete branch_;
    3393                                 branch_ = NULL;
    3394                             } else {
    3395                                 CbcBranchingObject * branchObj =
    3396                                     dynamic_cast <CbcBranchingObject *>(branch_) ;
    3397                                 assert (branchObj);
    3398                                 branchObj->way(preferredWay);
    3399                             }
    3400                         }
    34013391                    } else {
    34023392                        anyAction = -2;
     
    34063396            }
    34073397            // If  fixed then round again
    3408             if (!branch_ && anyAction != -2) {
     3398            // See if candidate still possible
     3399            if (branch_) {
     3400                 const OsiObject * object = model->object(bestChoice);
     3401                 int preferredWay;
     3402                 double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     3403                 if (!infeasibility) {
     3404                   // take out
     3405                   delete branch_;
     3406                   branch_ = NULL;
     3407                 } else {
     3408                   CbcBranchingObject * branchObj =
     3409                     dynamic_cast <CbcBranchingObject *>(branch_) ;
     3410                   assert (branchObj);
     3411                   branchObj->way(preferredWay);
     3412#ifdef CBCNODE_TIGHTEN_BOUNDS
     3413                   bool fixed = branchObj->tighten(solver);
     3414                   if (fixed) {
     3415                     //printf("Variable now fixed!\n");
     3416                     // take out
     3417                     delete branch_;
     3418                     branch_ = NULL;
     3419                   }
     3420#endif
     3421                 }
     3422            }
     3423            if (!branch_ && anyAction != -2 && !hitMaxTime) {
    34093424                finished = false;
    34103425            }
     
    34553470        if (numberUnfinished*10 > numberStrongDone + 1 ||
    34563471                !numberStrongInfeasible) {
    3457             printf("going to strategy 2\n");
     3472          COIN_DETAIL_PRINT(printf("going to strategy 2\n"));
    34583473            // Weaken
    34593474            model->setNumberStrong(2);
     
    38723887                // neither side feasible
    38733888                anyAction = -2;
    3874                 printf("Both infeasible for choice %d sequence %d\n", i,
    3875                        model->object(choice.objectNumber)->columnNumber());
     3889                COIN_DETAIL_PRINT(printf("Both infeasible for choice %d sequence %d\n", i,
     3890                                         model->object(choice.objectNumber)->columnNumber()));
    38763891                delete ws;
    38773892                ws = NULL;
     
    38893904        //     choice.downMovement,choice.upMovement,value);
    38903905    }
    3891     printf("Best possible solution %g, can fix more if solution of %g found - looked at %d variables in %d iterations\n",
    3892            objMin, objMax, iDo, model->numberAnalyzeIterations() - numberIterationsAllowed);
     3906    COIN_DETAIL_PRINT(printf("Best possible solution %g, can fix more if solution of %g found - looked at %d variables in %d iterations\n",
     3907                             objMin, objMax, iDo, model->numberAnalyzeIterations() - numberIterationsAllowed));
    38933908    model->setNumberAnalyzeIterations(numberIterationsAllowed);
    38943909    // Delete the snapshot
     
    43314346            bool gotSol = model->feasibleSolution(numInf, numInf2);
    43324347            if (!gotSol) {
    4333                 printf("numinf %d\n", numInf);
     4348              COIN_DETAIL_PRINT(printf("numinf %d\n", numInf));
    43344349                double * sol = simplex->primalColumnSolution();
    43354350                for (int i = 0; i < numberColumns; i++) {
     
    43374352                        double value = floor(sol[i] + 0.5);
    43384353                        if (fabs(value - sol[i]) > 1.0e-7) {
    4339                             printf("%d value %g\n", i, sol[i]);
     4354                          COIN_DETAIL_PRINT(printf("%d value %g\n", i, sol[i]));
    43404355                            if (fabs(value - sol[i]) < 1.0e-3) {
    43414356                                sol[i] = value;
Note: See TracChangeset for help on using the changeset viewer.