CbcNWay.hpp

Go to the documentation of this file.

// $Id: CbcNWay.hpp 1899 2013-04-09 18:12:08Z stefan $
// 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 CbcNWay_H
#define CbcNWay_H
 
class CbcNWay : public CbcObject {
 
public:
 
    // Default Constructor
    CbcNWay ();
 
    CbcNWay (CbcModel * model, int numberMembers,
             const int * which, int identifier);
 
    // Copy constructor
    CbcNWay ( const CbcNWay &);
 
    virtual CbcObject * clone() const;
 
    CbcNWay & operator=( const CbcNWay& rhs);
 
    virtual ~CbcNWay ();
 
    void setConsequence(int iColumn, const CbcConsequence & consequence);
 
    void applyConsequence(int iSequence, int state) const;
 
    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) ;
 
    inline int numberMembers() const {
        return numberMembers_;
    }
 
    inline const int * members() const {
        return members_;
    }
    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
 
protected:
    int numberMembers_;
 
    int * members_;
    CbcConsequence ** consequence_;
};
class CbcNWayBranchingObject : public CbcBranchingObject {
 
public:
 
    // Default Constructor
    CbcNWayBranchingObject ();
 
    CbcNWayBranchingObject (CbcModel * model,  const CbcNWay * nway,
                            int numberBranches, const int * order);
 
    // Copy constructor
    CbcNWayBranchingObject ( const CbcNWayBranchingObject &);
 
    // Assignment operator
    CbcNWayBranchingObject & operator=( const CbcNWayBranchingObject& rhs);
 
    virtual CbcBranchingObject * clone() const;
 
    // Destructor
    virtual ~CbcNWayBranchingObject ();
 
    using CbcBranchingObject::branch ;
    virtual double branch();
 
#ifdef JJF_ZERO
    // FIXME: what do we need to do here?
    virtual void previousBranch();
#endif
 
    using CbcBranchingObject::print ;
    virtual void print();
    virtual int numberBranches() const {
        return numberInSet_;
    }
    virtual bool twoWay() const {
        return false;
    }
 
    virtual CbcBranchObjType type() const {
        return NWayBranchObj;
    }
 
    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
 
    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
 
private:
    int * order_;
    const CbcNWay * object_;
    int numberInSet_;
};
#endif