CbcObject.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/12/2009 carved from CbcBranchBase
 
#ifndef CbcObject_H
#define CbcObject_H
 
#include <string>
#include <vector>
#include "OsiBranchingObject.hpp"
class OsiSolverInterface;
class OsiSolverBranch;
 
class CbcModel;
class CbcNode;
class CbcNodeInfo;
class CbcBranchingObject;
class OsiChooseVariable;
class CbcObjectUpdateData;
//#############################################################################

// This can be used if object wants to skip strong branching
typedef struct {
  CbcBranchingObject *possibleBranch; // what a branch would do
  double upMovement; // cost going up (and initial away from feasible)
  double downMovement; // cost going down
  int numIntInfeasUp; // without odd ones
  int numObjInfeasUp; // just odd ones
  bool finishedUp; // true if solver finished
  int numItersUp; // number of iterations in solver
  int numIntInfeasDown; // without odd ones
  int numObjInfeasDown; // just odd ones
  bool finishedDown; // true if solver finished
  int numItersDown; // number of iterations in solver
  int objectNumber; // Which object it is
  int fix; // 0 if no fix, 1 if we can fix up, -1 if we can fix down
} CbcStrongInfo;
 
class CbcObject : public OsiObject {
 
public:
  // Default Constructor
  CbcObject();
 
  // Useful constructor
  CbcObject(CbcModel *model);
 
  // Copy constructor
  CbcObject(const CbcObject &);
 
  // Assignment operator
  CbcObject &operator=(const CbcObject &rhs);

  virtual CbcObject *clone() const = 0;

  virtual ~CbcObject();

#ifdef CBC_NEW_STYLE_BRANCH
  virtual double infeasibility(const OsiBranchingInformation *info,
    int &preferredWay) const = 0;
#else
  virtual double infeasibility(const OsiBranchingInformation * /*info*/,
    int &preferredWay) const
  {
    return infeasibility(preferredWay);
  }
  virtual double infeasibility(int & /*preferredWay*/) const
  {
    throw CoinError("Need code", "infeasibility", "CbcBranchBase");
  }
#endif

  virtual void feasibleRegion() = 0;
  virtual double feasibleRegion(OsiSolverInterface *solver, const OsiBranchingInformation *info) const;

  virtual double feasibleRegion(OsiSolverInterface *solver) const;

#ifdef CBC_NEW_STYLE_BRANCH
  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) = 0;
#else
  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *
    /* solver */,
    const OsiBranchingInformation *
    /* info */,
    int /* way */)
  {
    // return createBranch(solver, info, way);
    return NULL;
  }
  virtual OsiBranchingObject *createBranch(OsiSolverInterface * /*solver*/,
    const OsiBranchingInformation * /*info*/, int /*way*/) const
  {
    throw CoinError("Need code", "createBranch", "CbcBranchBase");
  }
#endif
  virtual OsiBranchingObject *createOsiBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way) const;
  virtual OsiSolverBranch *solverBranch() const;

  virtual CbcBranchingObject *preferredNewFeasible() const
  {
    return NULL;
  }

  virtual CbcBranchingObject *notPreferredNewFeasible() const
  {
    return NULL;
  }

  virtual void resetBounds(const OsiSolverInterface *) {}

  virtual void floorCeiling(double &floorValue, double &ceilingValue, double value,
    double tolerance) const;

  virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface *solver,
    const CbcNode *node,
    const CbcBranchingObject *branchingObject);

  virtual void updateInformation(const CbcObjectUpdateData &) {}

  inline int id() const
  {
    return id_;
  }

  inline void setId(int value)
  {
    id_ = value;
  }

  inline bool optionalObject() const
  {
    return (id_ >= 1000000000 && id_ < 1100000000);
  }

  inline int position() const
  {
    return position_;
  }

  inline void setPosition(int position)
  {
    position_ = position;
  }

  inline void setModel(CbcModel *model)
  {
    model_ = model;
  }

  inline CbcModel *model() const
  {
    return model_;
  }

  inline int preferredWay() const
  {
    return preferredWay_;
  }

  inline void setPreferredWay(int value)
  {
    preferredWay_ = value;
  }

  virtual void redoSequenceEtc(CbcModel *, int, const int *) {}
  virtual void initializeForBranching(CbcModel *) {}
 
protected:

  CbcModel *model_;
  int id_;
  int position_;
  int preferredWay_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/