CbcSimpleInteger.hpp

Go to the documentation of this file.

// $Id$
// 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
};

/// Define a single integer class
 
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;
  }

  /// Breakeven e.g 0.7 -> >= 0.7 go up first
  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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/