CbcObject.hpp

Go to the documentation of this file.

// Edwin 11/12/2009 carved from CbcBranchBase
#ifndef CbcObject_H
#define CbcObject_H

#include <string>
#include <vector>
#include "OsiBranchingObject.hpp"
class OsiSolverInterface;
class OsiSolverBranch;

class CbcModel;
class CbcNode;
class CbcNodeInfo;
class CbcBranchingObject;
class OsiChooseVariable;
class CbcObjectUpdateData;
//#############################################################################

// This can be used if object wants to skip strong branching
typedef struct {
    CbcBranchingObject * possibleBranch; // what a branch would do
    double upMovement; // cost going up (and initial away from feasible)
    double downMovement; // cost going down
    int numIntInfeasUp ; // without odd ones
    int numObjInfeasUp ; // just odd ones
    bool finishedUp; // true if solver finished
    int numItersUp ; // number of iterations in solver
    int numIntInfeasDown ; // without odd ones
    int numObjInfeasDown ; // just odd ones
    bool finishedDown; // true if solver finished
    int numItersDown; // number of iterations in solver
    int objectNumber; // Which object it is
    int fix; // 0 if no fix, 1 if we can fix up, -1 if we can fix down
} CbcStrongInfo;

class CbcObject : public OsiObject {

public:

    // Default Constructor
    CbcObject ();

    // Useful constructor
    CbcObject (CbcModel * model);

    // Copy constructor
    CbcObject ( const CbcObject &);

    // Assignment operator
    CbcObject & operator=( const CbcObject& rhs);

    virtual CbcObject * clone() const = 0;

    virtual ~CbcObject ();

#ifdef CBC_NEW_STYLE_BRANCH
    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const = 0;
#else
    virtual double infeasibility(const OsiBranchingInformation * /*info*/,
                                 int &preferredWay) const {
        return infeasibility(preferredWay);
    }
    virtual double infeasibility(int &/*preferredWay*/) const {
        throw CoinError("Need code", "infeasibility", "CbcBranchBase");
    }
#endif

    virtual void feasibleRegion() = 0;
    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    virtual double feasibleRegion(OsiSolverInterface * solver) const ;

#ifdef CBC_NEW_STYLE_BRANCH
    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) = 0;
#else
    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) {
        return createBranch(solver, info, way);
    }
    virtual CbcBranchingObject * createBranch(OsiSolverInterface * /*solver*/,
            const OsiBranchingInformation * /*info*/, int /*way*/) {
        throw CoinError("Need code", "createBranch", "CbcBranchBase");
    }
#endif

    virtual OsiBranchingObject * createOsiBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
    virtual OsiSolverBranch * solverBranch() const;

    virtual CbcBranchingObject * preferredNewFeasible() const {
        return NULL;
    }

    virtual CbcBranchingObject * notPreferredNewFeasible() const {
        return NULL;
    }

    virtual void resetBounds(const OsiSolverInterface * ) {}

    virtual void floorCeiling(double & floorValue, double & ceilingValue, double value,
                              double tolerance) const;

    virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface * solver,
            const CbcNode * node,
            const CbcBranchingObject * branchingObject);

    virtual void updateInformation(const CbcObjectUpdateData & ) {}

    inline int id() const {
        return id_;
    }

    inline void setId(int value) {
        id_ = value;
    }

    inline bool optionalObject() const {
        return (id_ >= 1000000000 && id_ < 1100000000);
    }

    inline int position() const {
        return position_;
    }

    inline void setPosition(int position) {
        position_ = position;
    }

    inline void setModel(CbcModel * model) {
        model_ = model;
    }

    inline CbcModel * model() const {
        return  model_;
    }

    inline int preferredWay() const {
        return preferredWay_;
    }
    inline void setPreferredWay(int value) {
        preferredWay_ = value;
    }
    virtual void redoSequenceEtc(CbcModel * , int , const int * ) {}

protected:

    CbcModel * model_;
    int id_;
    int position_;
    int preferredWay_;

};

#endif