OsiBranchingObject.hpp

Go to the documentation of this file.

// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef OsiBranchingObject_H
#define OsiBranchingObject_H
 
#include <cassert>
#include <string>
#include <vector>
 
#include "CoinError.hpp"
#include "CoinTypes.hpp"
 
class OsiSolverInterface;
class OsiSolverBranch;
 
class OsiBranchingObject;
class OsiBranchingInformation;
 
//#############################################################################
//This contains the abstract base class for an object and for branching.
//It also contains a simple integer class
//#############################################################################
 
class OsiObject {
 
public:
  OsiObject();
 
  OsiObject(const OsiObject &);
 
  OsiObject &operator=(const OsiObject &rhs);
 
  virtual OsiObject *clone() const = 0;
 
  virtual ~OsiObject();
 
  double infeasibility(const OsiSolverInterface *solver, int &whichWay) const;
  // Faster version when more information available
  virtual double infeasibility(const OsiBranchingInformation *info, int &whichWay) const = 0;
  // This does NOT set mutable stuff
  virtual double checkInfeasibility(const OsiBranchingInformation *info) const;
 
  virtual double feasibleRegion(OsiSolverInterface *solver) const;
  virtual double feasibleRegion(OsiSolverInterface *solver, const OsiBranchingInformation *info) const = 0;
 
  virtual OsiBranchingObject *createBranch(OsiSolverInterface * /*solver*/,
    const OsiBranchingInformation * /*info*/,
    int /*way*/) const
  {
    throw CoinError("Need code", "createBranch", "OsiBranchingObject");
    return NULL;
  }
 
  virtual bool canDoHeuristics() const
  {
    return true;
  }
  virtual bool canMoveToNearest() const
  {
    return false;
  }
  virtual int columnNumber() const;
  inline int priority() const
  {
    return priority_;
  }
  inline void setPriority(int priority)
  {
    priority_ = priority;
  }
  virtual bool boundBranch() const
  {
    return true;
  }
  virtual bool canHandleShadowPrices() const
  {
    return false;
  }
  inline int numberWays() const
  {
    return numberWays_;
  }
  inline void setNumberWays(int numberWays)
  {
    numberWays_ = static_cast< short int >(numberWays);
  }
  inline void setWhichWay(int way)
  {
    whichWay_ = static_cast< short int >(way);
  }
  inline int whichWay() const
  {
    return whichWay_;
  }
  virtual int preferredWay() const
  {
    return -1;
  }
  inline double infeasibility() const
  {
    return infeasibility_;
  }
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  virtual void resetBounds(const OsiSolverInterface *) {}
  virtual void resetSequenceEtc(int, const int *) {}
  virtual void updateBefore(const OsiObject *) {}
  virtual void updateAfter(const OsiObject *, const OsiObject *) {}
 
protected:
 
  mutable double infeasibility_;
  mutable short whichWay_;
  short numberWays_;
  int priority_;
};
 
class OsiObject2 : public OsiObject {
 
public:
  OsiObject2();
 
  OsiObject2(const OsiObject2 &);
 
  OsiObject2 &operator=(const OsiObject2 &rhs);
 
  virtual ~OsiObject2();
 
  inline void setPreferredWay(int value)
  {
    preferredWay_ = value;
  }
 
  virtual int preferredWay() const
  {
    return preferredWay_;
  }
 
protected:
  int preferredWay_;
  mutable double otherInfeasibility_;
};
 
class OsiBranchingObject {
 
public:
  OsiBranchingObject();
 
  OsiBranchingObject(OsiSolverInterface *solver, double value);
 
  OsiBranchingObject(const OsiBranchingObject &);
 
  OsiBranchingObject &operator=(const OsiBranchingObject &rhs);
 
  virtual OsiBranchingObject *clone() const = 0;
 
  virtual ~OsiBranchingObject();
 
  inline int numberBranches() const
  {
    return numberBranches_;
  }
 
  inline int numberBranchesLeft() const
  {
    return numberBranches_ - branchIndex_;
  }
 
  inline void incrementNumberBranchesLeft()
  {
    numberBranches_++;
  }
 
  inline void setNumberBranchesLeft(int /*value*/)
  { /*assert (value==1&&!branchIndex_);*/
    numberBranches_ = 1;
  }
 
  inline void decrementNumberBranchesLeft()
  {
    branchIndex_++;
  }
 
  virtual double branch(OsiSolverInterface *solver) = 0;
  virtual double branch() { return branch(NULL); }
  virtual bool boundBranch() const
  {
    return true;
  }
  inline int branchIndex() const
  {
    return branchIndex_;
  }
 
  inline void setBranchingIndex(int branchIndex)
  {
    branchIndex_ = static_cast< short int >(branchIndex);
  }
 
  inline double value() const
  {
    return value_;
  }
 
  inline const OsiObject *originalObject() const
  {
    return originalObject_;
  }
  inline void setOriginalObject(const OsiObject *object)
  {
    originalObject_ = object;
  }
  virtual void checkIsCutoff(double) {}
  int columnNumber() const;
  virtual void print(const OsiSolverInterface * = NULL) const {}
 
protected:
  double value_;
 
  const OsiObject *originalObject_;
 
  int numberBranches_;
 
  short branchIndex_;
};
/* This contains information
   This could also contain pseudo shadow prices
   or information for dealing with computing and trusting pseudo-costs
*/
class OsiBranchingInformation {
 
public:
  OsiBranchingInformation();
 
  OsiBranchingInformation(const OsiSolverInterface *solver, bool normalSolver, bool copySolution = false);
 
  OsiBranchingInformation(const OsiBranchingInformation &);
 
  OsiBranchingInformation &operator=(const OsiBranchingInformation &rhs);
 
  virtual OsiBranchingInformation *clone() const;
 
  virtual ~OsiBranchingInformation();
 
  // Note public
public:
 
  int stateOfSearch_;
  double objectiveValue_;
  double cutoff_;
  double direction_;
  double integerTolerance_;
  double primalTolerance_;
  double timeRemaining_;
  double defaultDual_;
  mutable const OsiSolverInterface *solver_;
  int numberColumns_;
  mutable const double *lower_;
  mutable const double *solution_;
  mutable const double *upper_;
  const double *hotstartSolution_;
  const double *pi_;
  const double *rowActivity_;
  const double *objective_;
  const double *rowLower_;
  const double *rowUpper_;
  const double *elementByColumn_;
  const CoinBigIndex *columnStart_;
  const int *columnLength_;
  const int *row_;
  double *usefulRegion_;
  int *indexRegion_;
  int numberSolutions_;
  int numberBranchingSolutions_;
  int depth_;
  bool owningSolution_;
};
 
 
class OsiTwoWayBranchingObject : public OsiBranchingObject {
 
public:
  OsiTwoWayBranchingObject();
 
  OsiTwoWayBranchingObject(OsiSolverInterface *solver, const OsiObject *originalObject,
    int way, double value);
 
  OsiTwoWayBranchingObject(const OsiTwoWayBranchingObject &);
 
  OsiTwoWayBranchingObject &operator=(const OsiTwoWayBranchingObject &rhs);
 
  virtual ~OsiTwoWayBranchingObject();
 
  using OsiBranchingObject::branch;
  virtual double branch(OsiSolverInterface *solver) = 0;
 
  inline int firstBranch() const { return firstBranch_; }
  inline int way() const
  {
    return !branchIndex_ ? firstBranch_ : -firstBranch_;
  }
 
protected:
  int firstBranch_;
};
 
class OsiSimpleInteger : public OsiObject2 {
 
public:
  OsiSimpleInteger();
 
  OsiSimpleInteger(const OsiSolverInterface *solver, int iColumn);
 
  OsiSimpleInteger(int iColumn, double lower, double upper);
 
  OsiSimpleInteger(const OsiSimpleInteger &);
 
  virtual OsiObject *clone() const;
 
  OsiSimpleInteger &operator=(const OsiSimpleInteger &rhs);
 
  virtual ~OsiSimpleInteger();
 
  using OsiObject::infeasibility;
  virtual double infeasibility(const OsiBranchingInformation *info, int &whichWay) const;
 
  using OsiObject::feasibleRegion;
  virtual double feasibleRegion(OsiSolverInterface *solver, const OsiBranchingInformation *info) const;
 
  virtual OsiBranchingObject *createBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) const;
 
  inline void setColumnNumber(int value)
  {
    columnNumber_ = value;
  }
 
  virtual int columnNumber() const;
 
  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;
  }
  virtual void resetBounds(const OsiSolverInterface *solver);
  virtual void resetSequenceEtc(int numberColumns, const int *originalColumns);
 
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  virtual bool canHandleShadowPrices() const
  {
    return false;
  }
 
protected:
  double originalLower_;
  double originalUpper_;
  int columnNumber_;
};
class OsiIntegerBranchingObject : public OsiTwoWayBranchingObject {
 
public:
  OsiIntegerBranchingObject();
 
  OsiIntegerBranchingObject(OsiSolverInterface *solver, const OsiSimpleInteger *originalObject,
    int way, double value);
  OsiIntegerBranchingObject(OsiSolverInterface *solver, const OsiSimpleInteger *originalObject,
    int way, double value, double downUpperBound, double upLowerBound);
 
  OsiIntegerBranchingObject(const OsiIntegerBranchingObject &);
 
  OsiIntegerBranchingObject &operator=(const OsiIntegerBranchingObject &rhs);
 
  virtual OsiBranchingObject *clone() const;
 
  virtual ~OsiIntegerBranchingObject();
 
  using OsiBranchingObject::branch;
  virtual double branch(OsiSolverInterface *solver);
 
  using OsiBranchingObject::print;
  virtual void print(const OsiSolverInterface *solver = NULL);
 
protected:
  // Probably could get away with just value which is already stored
  double down_[2];
  double up_[2];
};
 
class OsiSOS : public OsiObject2 {
 
public:
  // Default Constructor
  OsiSOS();
 
  OsiSOS(const OsiSolverInterface *solver, int numberMembers,
    const int *which, const double *weights, int type = 1);
 
  // Copy constructor
  OsiSOS(const OsiSOS &);
 
  virtual OsiObject *clone() const;
 
  // Assignment operator
  OsiSOS &operator=(const OsiSOS &rhs);
 
  // Destructor
  virtual ~OsiSOS();
 
  using OsiObject::infeasibility;
  virtual double infeasibility(const OsiBranchingInformation *info, int &whichWay) const;
 
  using OsiObject::feasibleRegion;
  virtual double feasibleRegion(OsiSolverInterface *solver, const OsiBranchingInformation *info) const;
 
  virtual OsiBranchingObject *createBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) const;
  virtual double upEstimate() const;
  virtual double downEstimate() const;
 
  virtual void resetSequenceEtc(int numberColumns, const int *originalColumns);
 
  inline int numberMembers() const
  {
    return numberMembers_;
  }
 
  inline const int *members() const
  {
    return members_;
  }
 
  inline int sosType() const
  {
    return sosType_;
  }
 
  inline int setType() const
  {
    return sosType_;
  }
 
  inline const double *weights() const
  {
    return weights_;
  }
 
  virtual bool canDoHeuristics() const
  {
    return (sosType_ == 1 && integerValued_);
  }
  inline void setIntegerValued(bool yesNo)
  {
    integerValued_ = yesNo;
  }
  virtual bool canHandleShadowPrices() const
  {
    return true;
  }
  inline void setNumberMembers(int value)
  {
    numberMembers_ = value;
  }
 
  inline int *mutableMembers() const
  {
    return members_;
  }
 
  inline void setSosType(int value)
  {
    sosType_ = value;
  }
 
  inline double *mutableWeights() const
  {
    return weights_;
  }
 
protected:
 
  int *members_;
  double *weights_;
 
  int numberMembers_;
  int sosType_;
  bool integerValued_;
};
 
class OsiSOSBranchingObject : public OsiTwoWayBranchingObject {
 
public:
  // Default Constructor
  OsiSOSBranchingObject();
 
  // Useful constructor
  OsiSOSBranchingObject(OsiSolverInterface *solver, const OsiSOS *originalObject,
    int way,
    double separator);
 
  // Copy constructor
  OsiSOSBranchingObject(const OsiSOSBranchingObject &);
 
  // Assignment operator
  OsiSOSBranchingObject &operator=(const OsiSOSBranchingObject &rhs);
 
  virtual OsiBranchingObject *clone() const;
 
  // Destructor
  virtual ~OsiSOSBranchingObject();
 
  using OsiBranchingObject::branch;
  virtual double branch(OsiSolverInterface *solver);
 
  using OsiBranchingObject::print;
  virtual void print(const OsiSolverInterface *solver = NULL);
 
private:
};
class OsiLotsize : public OsiObject2 {
 
public:
  // Default Constructor
  OsiLotsize();
 
  /* Useful constructor - passed model index.
     Also passed valid values - if range then pairs
  */
  OsiLotsize(const OsiSolverInterface *solver, int iColumn,
    int numberPoints, const double *points, bool range = false);
 
  // Copy constructor
  OsiLotsize(const OsiLotsize &);
 
  virtual OsiObject *clone() const;
 
  // Assignment operator
  OsiLotsize &operator=(const OsiLotsize &rhs);
 
  // Destructor
  virtual ~OsiLotsize();
 
  using OsiObject::infeasibility;
  virtual double infeasibility(const OsiBranchingInformation *info, int &whichWay) const;
 
  using OsiObject::feasibleRegion;
  virtual double feasibleRegion(OsiSolverInterface *solver, const OsiBranchingInformation *info) const;
 
  virtual OsiBranchingObject *createBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) const;
 
  inline void setColumnNumber(int value)
  {
    columnNumber_ = value;
  }
 
  virtual int columnNumber() const;
  virtual void resetBounds(const OsiSolverInterface *solver);
 
  bool findRange(double value, double integerTolerance) const;
 
  virtual void floorCeiling(double &floorLotsize, double &ceilingLotsize, double value,
    double tolerance) 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 void resetSequenceEtc(int numberColumns, const int *originalColumns);
 
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  virtual bool canHandleShadowPrices() const
  {
    return true;
  }
  virtual bool canDoHeuristics() const
  {
    return false;
  }
 
private:
 
  int columnNumber_;
  int rangeType_;
  int numberRanges_;
  // largest gap
  double largestGap_;
  double *bound_;
  mutable int range_;
};
 
class OsiLotsizeBranchingObject : public OsiTwoWayBranchingObject {
 
public:
  OsiLotsizeBranchingObject();
 
  OsiLotsizeBranchingObject(OsiSolverInterface *solver, const OsiLotsize *originalObject,
    int way, double value);
 
  OsiLotsizeBranchingObject(const OsiLotsizeBranchingObject &);
 
  OsiLotsizeBranchingObject &operator=(const OsiLotsizeBranchingObject &rhs);
 
  virtual OsiBranchingObject *clone() const;
 
  virtual ~OsiLotsizeBranchingObject();
 
  using OsiBranchingObject::branch;
  virtual double branch(OsiSolverInterface *solver);
 
  using OsiBranchingObject::print;
  virtual void print(const OsiSolverInterface *solver = NULL);
 
protected:
  double down_[2];
  double up_[2];
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/