CbcBranchDynamic.hpp

Go to the documentation of this file.

/* $Id: CbcBranchDynamic.hpp 1432 2010-02-07 19:33:53Z bjarni $ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
#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