CbcBranchLotsize.hpp

Go to the documentation of this file.

/* $Id: CbcBranchLotsize.hpp 1573 2011-01-05 01:12:36Z lou $ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcBranchLotsize_H
#define CbcBranchLotsize_H
 
#include "CbcBranchBase.hpp"
class CbcLotsize : public CbcObject {
 
public:
 
    // Default Constructor
    CbcLotsize ();
 
    /* Useful constructor - passed model index.
       Also passed valid values - if range then pairs
    */
    CbcLotsize (CbcModel * model, int iColumn,
                int numberPoints, const double * points, bool range = false);
 
    // Copy constructor
    CbcLotsize ( const CbcLotsize &);
 
    virtual CbcObject * clone() const;
 
    // Assignment operator
    CbcLotsize & operator=( const CbcLotsize& rhs);
 
    // Destructor
    ~CbcLotsize ();
 
    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 CbcBranchingObject * preferredNewFeasible() const;
 
    virtual CbcBranchingObject * notPreferredNewFeasible() const ;
 
    virtual void resetBounds(const OsiSolverInterface * solver);
 
    bool findRange(double value) const;
 
    virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
                              double tolerance) const;
 
    inline int modelSequence() const {
        return columnNumber_;
    }
    inline void setModelSequence(int value) {
        columnNumber_ = value;
    }
 
    virtual int columnNumber() const;
    inline double originalLowerBound() const {
        return bound_[0];
    }
    inline double originalUpperBound() const {
        return bound_[rangeType_*numberRanges_-1];
    }
    inline int rangeType() const {
        return rangeType_;
    }
    inline int numberRanges() const {
        return numberRanges_;
    }
    inline double * bound() const {
        return bound_;
    }
    virtual bool canDoHeuristics() const {
        return false;
    }
 
private:
    void printLotsize(double value, bool condition, int type) const;
 
private:
 
    int columnNumber_;
    int rangeType_;
    int numberRanges_;
    // largest gap
    double largestGap_;
    double * bound_;
    mutable int range_;
};
 
class CbcLotsizeBranchingObject : public CbcBranchingObject {
 
public:
 
    CbcLotsizeBranchingObject ();
 
    CbcLotsizeBranchingObject (CbcModel *model, int variable,
                               int way , double value, const CbcLotsize * lotsize) ;
 
    CbcLotsizeBranchingObject (CbcModel *model, int variable, int way,
                               double lowerValue, double upperValue) ;
 
    CbcLotsizeBranchingObject ( const CbcLotsizeBranchingObject &);
 
    CbcLotsizeBranchingObject & operator= (const CbcLotsizeBranchingObject& rhs);
 
    virtual CbcBranchingObject * clone() const;
 
    virtual ~CbcLotsizeBranchingObject ();
 
    using CbcBranchingObject::branch ;
    virtual double branch();
 
    using CbcBranchingObject::print ;
    virtual void print();
 
    virtual CbcBranchObjType type() const {
        return LotsizeBranchObj;
    }
 
    // LL: compareOriginalObject can be inherited from the CbcBranchingObject
    // since variable_ uniquely defines the lot sizing object.
 
    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
 
protected:
    double down_[2];
    double up_[2];
};
 
#endif