/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcBranchLotsize.hpp

Go to the documentation of this file.

// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
#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 ();
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

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

  using CbcObject::createBranch ;
  virtual CbcBranchingObject * createBranch(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_;}

  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();

#if 0
  // No need to override. Default works fine.
  virtual void previousBranch();
#endif

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

  virtual int type() const { return 300; }

  // 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

---