CbcBranchDynamic.hpp

Go to the documentation of this file.

/* $Id: CbcBranchDynamic.hpp 1573 2011-01-05 01:12:36Z lou $ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcBranchDynamic_H
#define CbcBranchDynamic_H
 
#include "CoinPackedMatrix.hpp"
#include "CbcSimpleIntegerDynamicPseudoCost.hpp"
#include "CbcBranchActual.hpp"
 
class CbcBranchDynamicDecision : public CbcBranchDecision {
public:
    // Default Constructor
    CbcBranchDynamicDecision ();
 
    // Copy constructor
    CbcBranchDynamicDecision ( const CbcBranchDynamicDecision &);
 
    virtual ~CbcBranchDynamicDecision();
 
    virtual CbcBranchDecision * clone() const;
 
    virtual void initialize(CbcModel * model);
 
    virtual int betterBranch(CbcBranchingObject * thisOne,
                             CbcBranchingObject * bestSoFar,
                             double changeUp, int numInfUp,
                             double changeDn, int numInfDn);
    virtual void setBestCriterion(double value);
    virtual double getBestCriterion() const;
    virtual int whichMethod() {
        return 3;
    }
 
    virtual void saveBranchingObject(OsiBranchingObject * object) ;
    virtual void updateInformation(OsiSolverInterface * solver,
                                   const CbcNode * node);
 
 
private:
 
    CbcBranchDynamicDecision & operator=(const CbcBranchDynamicDecision& rhs);
 
 
    double bestCriterion_;
 
    double bestChangeUp_;
 
    int bestNumberUp_;
 
    double bestChangeDown_;
 
    int bestNumberDown_;
 
    CbcBranchingObject * bestObject_;
};
class CbcDynamicPseudoCostBranchingObject : public CbcIntegerBranchingObject {
 
public:
 
    CbcDynamicPseudoCostBranchingObject ();
 
    CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable,
                                         int way , double value,
                                         CbcSimpleIntegerDynamicPseudoCost * object) ;
 
    CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable, int way,
                                         double lowerValue, double upperValue) ;
 
    CbcDynamicPseudoCostBranchingObject ( const CbcDynamicPseudoCostBranchingObject &);
 
    CbcDynamicPseudoCostBranchingObject & operator= (const CbcDynamicPseudoCostBranchingObject& rhs);
 
    virtual CbcBranchingObject * clone() const;
 
    virtual ~CbcDynamicPseudoCostBranchingObject ();
 
    void fillPart (int variable,
                   int way , double value,
                   CbcSimpleIntegerDynamicPseudoCost * object) ;
 
    using CbcBranchingObject::branch ;
    virtual double branch();
 
    virtual int fillStrongInfo( CbcStrongInfo & info);
 
    inline double changeInGuessed() const {
        return changeInGuessed_;
    }
    inline void setChangeInGuessed(double value) {
        changeInGuessed_ = value;
    }
    inline CbcSimpleIntegerDynamicPseudoCost * object() const {
        return object_;
    }
    inline void setObject(CbcSimpleIntegerDynamicPseudoCost * object) {
        object_ = object;
    }
 
    virtual CbcBranchObjType type() const {
        return DynamicPseudoCostBranchObj;
    }
 
    // LL: compareOriginalObject and compareBranchingObject are inherited from
    // CbcIntegerBranchingObject thus need not be declared/defined here. After
    // all, this kind of branching object is simply using pseudocosts to make
    // decisions, but once the decisions are made they are the same kind as in
    // the underlying class.
 
protected:
    double changeInGuessed_;
    CbcSimpleIntegerDynamicPseudoCost * object_;
 
};
 
#endif