CbcSOS.hpp

Go to the documentation of this file.

// $Id: CbcSOS.hpp 2465 2019-01-03 19:26:52Z unxusr $
// 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
*/