CbcSOS.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 CbcSOS_H
#define CbcSOS_H
 
class CbcSOS : public CbcObject {
 
public:
  // Default Constructor
  CbcSOS();
 
  CbcSOS(CbcModel *model, int numberMembers,
    const int *which, const double *weights, int identifier,
    int type = 1);
 
  // Copy constructor
  CbcSOS(const CbcSOS &);
 
  virtual CbcObject *clone() const;
 
  // Assignment operator
  CbcSOS &operator=(const CbcSOS &rhs);
 
  // Destructor
  virtual ~CbcSOS();
 
  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 CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface *solver,
    const CbcNode *node,
    const CbcBranchingObject *branchingObject);
  virtual void updateInformation(const CbcObjectUpdateData &data);
  using CbcObject::solverBranch;
  virtual OsiSolverBranch *solverBranch() const;
  virtual void redoSequenceEtc(CbcModel *model, int numberColumns, const int *originalColumns);
 
  OsiSOS *osiObject(const OsiSolverInterface *solver) const;
  inline int numberMembers() const
  {
    return numberMembers_;
  }
 
  inline const int *members() const
  {
    return members_;
  }
 
  inline int sosType() const
  {
    return sosType_;
  }
  inline int numberTimesDown() const
  {
    return numberTimesDown_;
  }
  inline int numberTimesUp() const
  {
    return numberTimesUp_;
  }
 
  inline const double *weights() const
  {
    return weights_;
  }
 
  inline void setNumberMembers(int n)
  {
    numberMembers_ = n;
  }
 
  inline int *mutableMembers() const
  {
    return members_;
  }
 
  inline double *mutableWeights() const
  {
    return weights_;
  }
 
  virtual bool canDoHeuristics() const
  {
    return (sosType_ == 1 && integerValued_);
  }
  inline void setIntegerValued(bool yesNo)
  {
    integerValued_ = yesNo;
  }
 
protected:
 
  int *members_;
  double *weights_;
  mutable double shadowEstimateDown_;
  mutable double shadowEstimateUp_;
  double downDynamicPseudoRatio_;
  double upDynamicPseudoRatio_;
  int numberTimesDown_;
  int numberTimesUp_;
  int numberMembers_;
  int sosType_;
  bool integerValued_;
  bool oddValues_;
};
 
class CbcSOSBranchingObject : public CbcBranchingObject {
 
public:
  // Default Constructor
  CbcSOSBranchingObject();
 
  // Useful constructor
  CbcSOSBranchingObject(CbcModel *model, const CbcSOS *clique,
    int way,
    double separator);
 
  // Copy constructor
  CbcSOSBranchingObject(const CbcSOSBranchingObject &);
 
  // Assignment operator
  CbcSOSBranchingObject &operator=(const CbcSOSBranchingObject &rhs);
 
  virtual CbcBranchingObject *clone() const;
 
  // Destructor
  virtual ~CbcSOSBranchingObject();
 
  using CbcBranchingObject::branch;
  virtual double branch();
  virtual void fix(OsiSolverInterface *solver,
    double *lower, double *upper,
    int branchState) const;
 
  virtual void previousBranch()
  {
    CbcBranchingObject::previousBranch();
    computeNonzeroRange();
  }
 
  using CbcBranchingObject::print;
  virtual void print();
 
  virtual CbcBranchObjType type() const
  {
    return SoSBranchObj;
  }
 
  virtual int compareOriginalObject(const CbcBranchingObject *brObj) const;
 
  virtual CbcRangeCompare compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap = false);
 
  void computeNonzeroRange();
 
protected:
  const CbcSOS *set_;
  double separator_;
  int firstNonzero_;
  int lastNonzero_;
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/