CbcSimpleInteger.hpp

Go to the documentation of this file.

// $Id: CbcSimpleInteger.hpp 1943 2013-07-21 09:05: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 CbcSimpleInteger_H
#define CbcSimpleInteger_H
 
#include "CbcBranchingObject.hpp"
 
class CbcIntegerBranchingObject : public CbcBranchingObject {
 
public:
 
    CbcIntegerBranchingObject ();
 
    CbcIntegerBranchingObject (CbcModel *model, int variable,
                               int way , double value) ;
 
    CbcIntegerBranchingObject (CbcModel *model, int variable, int way,
                               double lowerValue, double upperValue) ;
 
    CbcIntegerBranchingObject ( const CbcIntegerBranchingObject &);
 
    CbcIntegerBranchingObject & operator= (const CbcIntegerBranchingObject& rhs);
 
    virtual CbcBranchingObject * clone() const;
 
    virtual ~CbcIntegerBranchingObject ();
 
    void fillPart ( int variable, int way , double value) ;
    using CbcBranchingObject::branch ;
    virtual double branch();
    virtual void fix(OsiSolverInterface * solver,
                     double * lower, double * upper,
                     int branchState) const ;
    virtual bool tighten(OsiSolverInterface * ) ;
 
#ifdef JJF_ZERO
    // No need to override. Default works fine.
    virtual void previousBranch();
#endif
 
    using CbcBranchingObject::print ;
    virtual void print();
 
    inline const double * downBounds() const {
        return down_;
    }
    inline const double * upBounds() const {
        return up_;
    }
    inline void setDownBounds(const double bounds[2]) {
        memcpy(down_, bounds, 2*sizeof(double));
    }
    inline void setUpBounds(const double bounds[2]) {
        memcpy(up_, bounds, 2*sizeof(double));
    }
#ifdef FUNNY_BRANCHING
 
    inline const int * variables() const {
        return variables_;
    }
    // New bound
    inline const double * newBounds() const {
        return newBounds_;
    }
    inline int numberExtraChangedBounds() const {
        return numberExtraChangedBounds_;
    }
    int applyExtraBounds(int iColumn, double lower, double upper, int way) ;
    void deactivate();
    inline bool active() const {
        return (down_[1] != -COIN_DBL_MAX);
    }
#endif
 
    virtual CbcBranchObjType type() const {
        return SimpleIntegerBranchObj;
    }
 
    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
 
protected:
    double down_[2];
    double up_[2];
#ifdef FUNNY_BRANCHING
 
    int * variables_;
    // New bound
    double * newBounds_;
    int numberExtraChangedBounds_;
#endif
};
 
 
 
class CbcSimpleInteger : public CbcObject {
 
public:
 
    // Default Constructor
    CbcSimpleInteger ();
 
    // Useful constructor - passed model and index
    CbcSimpleInteger (CbcModel * model,  int iColumn, double breakEven = 0.5);
 
    // Useful constructor - passed model and Osi object
    CbcSimpleInteger (CbcModel * model,  const OsiSimpleInteger * object);
 
    // Copy constructor
    CbcSimpleInteger ( const CbcSimpleInteger &);
 
    virtual CbcObject * clone() const;
 
    // Assignment operator
    CbcSimpleInteger & operator=( const CbcSimpleInteger& rhs);
 
    // Destructor
    virtual ~CbcSimpleInteger ();
    OsiSimpleInteger * osiObject() const;
    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const;
 
    using CbcObject::feasibleRegion ;
    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
 
    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
  /*virtual*/ void fillCreateBranch(CbcIntegerBranchingObject * branching, const OsiBranchingInformation * info, int way) ;
 
    using CbcObject::solverBranch ;
    virtual OsiSolverBranch * solverBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
 
    virtual void feasibleRegion();
 
    virtual int columnNumber() const;
    inline void setColumnNumber(int value) {
        columnNumber_ = value;
    }
 
    virtual void resetBounds(const OsiSolverInterface * solver) ;
 
    virtual void resetSequenceEtc(int numberColumns, const int * originalColumns) ;
    inline double originalLowerBound() const {
        return originalLower_;
    }
    inline void setOriginalLowerBound(double value) {
        originalLower_ = value;
    }
    inline double originalUpperBound() const {
        return originalUpper_;
    }
    inline void setOriginalUpperBound(double value) {
        originalUpper_ = value;
    }
    inline double breakEven() const {
        return breakEven_;
    }
    inline void setBreakEven(double value) {
        breakEven_ = value;
    }
 
 
protected:
 
    double originalLower_;
    double originalUpper_;
    double breakEven_;
    int columnNumber_;
    int preferredWay_;
};
#endif