Changeset 1624


Ignore:
Timestamp:
Mar 25, 2011 3:05:49 PM (8 years ago)
Author:
forrest
Message:

fix bad bound message

Location:
trunk/Cbc/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcBranchingObject.hpp

    r1573 r1624  
    112112                     int ) const {}
    113113
     114    /** Change (tighten) bounds in object to reflect bounds in solver.
     115        Return true if now fixed */
     116    virtual bool tighten(OsiSolverInterface * ) {return false;}
     117
    114118    /** Reset every information so that the branching object appears to point to
    115119        the previous child. This method does not need to modify anything in any
  • trunk/Cbc/src/CbcNode.cpp

    r1605 r1624  
    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) {
     
    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
     
    28612861                            numberStrongInfeasible++;
    28622862                        } else {
    2863                             //#define TIGHTEN_BOUNDS
    2864 #ifdef TIGHTEN_BOUNDS
     2863#define CBCNODE_TIGHTEN_BOUNDS
     2864#ifdef CBCNODE_TIGHTEN_BOUNDS
    28652865                            // Can we tighten bounds?
    28662866                            if (iColumn < numberColumns && cutoff < 1.0e20
     
    30083008                            numberStrongInfeasible++;
    30093009                        } else {
    3010 #ifdef TIGHTEN_BOUNDS
     3010#ifdef CBCNODE_TIGHTEN_BOUNDS
    30113011                            // Can we tighten bounds?
    30123012                            if (iColumn < numberColumns && cutoff < 1.0e20
     
    33213321                }
    33223322                // Check max time
    3323                 hitMaxTime = ( CoinCpuTime() - model->getDblParam(CbcModel::CbcStartSeconds) >
     3323                hitMaxTime = (model->getCurrentSeconds() >
    33243324                               model->getDblParam(CbcModel::CbcMaximumSeconds));
    33253325                if (hitMaxTime) {
     
    33833383                    if (feasible) {
    33843384                        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                         }
    34013385                    } else {
    34023386                        anyAction = -2;
     
    34063390            }
    34073391            // If  fixed then round again
    3408             if (!branch_ && anyAction != -2) {
     3392            // See if candidate still possible
     3393            if (branch_) {
     3394                 const OsiObject * object = model->object(bestChoice);
     3395                 int preferredWay;
     3396                 double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     3397                 if (!infeasibility) {
     3398                   // take out
     3399                   delete branch_;
     3400                   branch_ = NULL;
     3401                 } else {
     3402                   CbcBranchingObject * branchObj =
     3403                     dynamic_cast <CbcBranchingObject *>(branch_) ;
     3404                   assert (branchObj);
     3405                   branchObj->way(preferredWay);
     3406#ifdef CBCNODE_TIGHTEN_BOUNDS
     3407                   bool fixed = branchObj->tighten(solver);
     3408                   if (fixed) {
     3409                     printf("Variable now fixed!\n");
     3410                     // take out
     3411                     delete branch_;
     3412                     branch_ = NULL;
     3413                   }
     3414#endif
     3415                 }
     3416            }
     3417            if (!branch_ && anyAction != -2 && !hitMaxTime) {
    34093418                finished = false;
    34103419            }
  • trunk/Cbc/src/CbcSimpleInteger.cpp

    r1608 r1624  
    424424    olb = model_->solver()->getColLower()[iColumn] ;
    425425    oub = model_->solver()->getColUpper()[iColumn] ;
    426     //#define TIGHTEN_BOUNDS
    427 #ifndef TIGHTEN_BOUNDS
     426    //#define CBCSIMPLE_TIGHTEN_BOUNDS
     427#ifndef CBCSIMPLE_TIGHTEN_BOUNDS
    428428#ifdef COIN_DEVELOP
    429429    if (olb != down_[0] || oub != up_[1]) {
     
    446446        }
    447447#endif
    448 #ifndef TIGHTEN_BOUNDS
     448#ifndef CBCSIMPLE_TIGHTEN_BOUNDS
    449449        model_->solver()->setColLower(iColumn, down_[0]);
    450450#else
     
    452452#endif
    453453        model_->solver()->setColUpper(iColumn, down_[1]);
    454         //#define CBC_PRINT2
     454        //#define CBC_PRINT2
    455455#ifdef CBC_PRINT2
    456456        printf("%d branching down has bounds %g %g", iColumn, down_[0], down_[1]);
     
    496496#endif
    497497        model_->solver()->setColLower(iColumn, up_[0]);
    498 #ifndef TIGHTEN_BOUNDS
     498#ifndef CBCSIMPLE_TIGHTEN_BOUNDS
    499499        model_->solver()->setColUpper(iColumn, up_[1]);
    500500#else
     
    541541        printf("bad lb change for column %d from %g to %g\n", iColumn, olb, nlb);
    542542#endif
     543        //abort();
    543544        model_->solver()->setColLower(iColumn, CoinMin(olb, nub));
    544545        nlb = olb;
     
    548549        printf("bad ub change for column %d from %g to %g\n", iColumn, oub, nub);
    549550#endif
     551        //abort();
    550552        model_->solver()->setColUpper(iColumn, CoinMax(oub, nlb));
    551553    }
     
    576578        upper[iColumn] = up_[1];
    577579    }
     580}
     581// Change (tighten) bounds in object to reflect bounds in solver.
     582// Return true if now fixed
     583bool
     584CbcIntegerBranchingObject::tighten(OsiSolverInterface * solver)
     585{
     586    double lower = solver->getColLower()[variable_];
     587    double upper = solver->getColUpper()[variable_];
     588    assert (upper>lower);
     589    down_[0] = CoinMax(down_[0],lower);
     590    up_[0] = CoinMax(up_[0],lower);
     591    down_[1] = CoinMin(down_[1],upper);
     592    up_[1] = CoinMin(up_[1],upper);
     593    return (down_[0]==up_[1]);
    578594}
    579595#ifdef FUNNY_BRANCHING
  • trunk/Cbc/src/CbcSimpleInteger.hpp

    r1573 r1624  
    7171                     double * lower, double * upper,
    7272                     int branchState) const ;
     73    /** Change (tighten) bounds in object to reflect bounds in solver.
     74        Return true if now fixed */
     75    virtual bool tighten(OsiSolverInterface * ) ;
    7376
    7477#ifdef JJF_ZERO
     
    237240     */
    238241    virtual void resetBounds(const OsiSolverInterface * solver) ;
     242
    239243    /**  Change column numbers after preprocessing
    240244     */
Note: See TracChangeset for help on using the changeset viewer.