CbcSOS.hpp

Go to the documentation of this file.

// $Id: CbcSOS.hpp 2070 2014-09-08 09:24:45Z forrest $
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
// 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_;
    bool oddValues_;
};
 
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