CbcBranchLotsize.hpp

Go to the documentation of this file.

/* $Id$ */
// 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;
 
protected:
 
  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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/