CbcSOS.hpp

Go to the documentation of this file.

// Edwin 11/9/2009-- carved out of CbcBranchActual
#ifndef CbcSOS_H
#define CbcSOS_H

class CbcSOS : public CbcObject {

public:

    // Default Constructor
    CbcSOS ();

    CbcSOS (CbcModel * model, int numberMembers,
            const int * which, const double * weights, int identifier,
            int type = 1);

    // Copy constructor
    CbcSOS ( const CbcSOS &);

    virtual CbcObject * clone() const;

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

    // Destructor
    virtual ~CbcSOS ();

    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const;

    using CbcObject::feasibleRegion ;
    virtual void feasibleRegion();

    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;



    virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface * solver,
            const CbcNode * node,
            const CbcBranchingObject * branchingObject);
    virtual void updateInformation(const CbcObjectUpdateData & data) ;
    using CbcObject::solverBranch ;
    virtual OsiSolverBranch * solverBranch() const;
    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);

    OsiSOS * osiObject(const OsiSolverInterface * solver) const;
    inline int numberMembers() const {
        return numberMembers_;
    }

    inline const int * members() const {
        return members_;
    }

    inline int sosType() const {
        return sosType_;
    }
    inline int numberTimesDown() const {
        return numberTimesDown_;
    }
    inline int numberTimesUp() const {
        return numberTimesUp_;
    }

    inline const double * weights() const {
        return weights_;
    }

    inline void setNumberMembers(int n) {
        numberMembers_ = n;
    }

    inline int * mutableMembers() const {
        return members_;
    }

    inline double * mutableWeights() const {
        return weights_;
    }

    virtual bool canDoHeuristics() const {
        return (sosType_ == 1 && integerValued_);
    }
    inline void setIntegerValued(bool yesNo) {
        integerValued_ = yesNo;
    }
private:

    int * members_;
    double * weights_;
    mutable double shadowEstimateDown_;
    mutable double shadowEstimateUp_;
    double downDynamicPseudoRatio_;
    double upDynamicPseudoRatio_;
    int numberTimesDown_;
    int numberTimesUp_;
    int numberMembers_;
    int sosType_;
    bool integerValued_;
};

class CbcSOSBranchingObject : public CbcBranchingObject {

public:

    // Default Constructor
    CbcSOSBranchingObject ();

    // Useful constructor
    CbcSOSBranchingObject (CbcModel * model,  const CbcSOS * clique,
                           int way,
                           double separator);

    // Copy constructor
    CbcSOSBranchingObject ( const CbcSOSBranchingObject &);

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

    virtual CbcBranchingObject * clone() const;

    // Destructor
    virtual ~CbcSOSBranchingObject ();

    using CbcBranchingObject::branch ;
    virtual double branch();
    virtual void fix(OsiSolverInterface * solver,
                     double * lower, double * upper,
                     int branchState) const ;

    virtual void previousBranch() {
        CbcBranchingObject::previousBranch();
        computeNonzeroRange();
    }

    using CbcBranchingObject::print ;
    virtual void print();

    virtual CbcBranchObjType type() const {
        return SoSBranchObj;
    }

    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);

    void computeNonzeroRange();

private:
    const CbcSOS * set_;
    double separator_;
    int firstNonzero_;
    int lastNonzero_;
};
#endif