CbcNodeInfo.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/24/09 carved from CbcNode
 
#ifndef CbcNodeInfo_H
#define CbcNodeInfo_H
 
#include <string>
#include <vector>
 
#include "CoinWarmStartBasis.hpp"
#include "CoinSearchTree.hpp"
#include "CbcBranchBase.hpp"
 
class OsiSolverInterface;
class OsiSolverBranch;
 
class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinWarmStartBasis;
class CbcCountRowCut;
class CbcModel;
class CbcNode;
class CbcSubProblem;
class CbcGeneralBranchingObject;
 
//#############################################################################
class CbcNodeInfo {
 
public:
  CbcNodeInfo();
 
  CbcNodeInfo(const CbcNodeInfo &);
 
#ifdef JJF_ZERO
 
  CbcNodeInfo(CbcNodeInfo *parent);
#endif
 
  CbcNodeInfo(CbcNodeInfo *parent, CbcNode *owner);
 
  virtual ~CbcNodeInfo();
 
  virtual void applyToModel(CbcModel *model, CoinWarmStartBasis *&basis,
    CbcCountRowCut **addCuts,
    int &currentNumberCuts) const = 0;
  virtual int applyBounds(int iColumn, double &lower, double &upper, int force) = 0;
 
  virtual CbcNodeInfo *buildRowBasis(CoinWarmStartBasis &basis) const = 0;
  virtual CbcNodeInfo *clone() const = 0;
  virtual void allBranchesGone() {}
#ifndef JJF_ONE
  inline void increment(int amount = 1)
  {
    numberPointingToThis_ += amount; /*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/
  }
 
  inline int decrement(int amount = 1)
  {
    numberPointingToThis_ -= amount; /*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/
    return numberPointingToThis_;
  }
#else
  void increment(int amount = 1);
  int decrement(int amount = 1);
#endif
 
  inline void initializeInfo(int number)
  {
    numberPointingToThis_ = number;
    numberBranchesLeft_ = number;
  }
 
  inline int numberBranchesLeft() const
  {
    return numberBranchesLeft_;
  }
 
  inline void setNumberBranchesLeft(int value)
  {
    numberBranchesLeft_ = value;
  }
 
  inline int numberPointingToThis() const
  {
    return numberPointingToThis_;
  }
 
  inline void setNumberPointingToThis(int number)
  {
    numberPointingToThis_ = number;
  }
 
  inline void incrementNumberPointingToThis()
  {
    numberPointingToThis_++;
  }
 
  inline int branchedOn()
  {
    numberPointingToThis_--;
    numberBranchesLeft_--;
    return numberBranchesLeft_;
  }
 
  inline void throwAway()
  {
    numberPointingToThis_ -= numberBranchesLeft_;
    numberBranchesLeft_ = 0;
  }
 
  CbcNodeInfo *parent() const
  {
    return parent_;
  }
  inline void nullParent()
  {
    parent_ = NULL;
  }
 
  void addCuts(OsiCuts &cuts, int numberToBranch, //int * whichGenerator,
    int numberPointingToThis);
  void addCuts(int numberCuts, CbcCountRowCut **cuts, int numberToBranch);
  void deleteCuts(int numberToDelete, CbcCountRowCut **cuts);
  void deleteCuts(int numberToDelete, int *which);
 
  void deleteCut(int whichOne);
 
  void decrementCuts(int change = 1);
 
  void incrementCuts(int change = 1);
 
  void decrementParentCuts(CbcModel *model, int change = 1);
 
  void incrementParentCuts(CbcModel *model, int change = 1);
 
  inline CbcCountRowCut **cuts() const
  {
    return cuts_;
  }
 
  inline int numberCuts() const
  {
    return numberCuts_;
  }
  inline void setNumberCuts(int value)
  {
    numberCuts_ = value;
  }
 
  inline void nullOwner()
  {
    owner_ = NULL;
  }
  const inline CbcNode *owner() const
  {
    return owner_;
  }
  inline CbcNode *mutableOwner() const
  {
    return owner_;
  }
  inline int nodeNumber() const
  {
    return nodeNumber_;
  }
  inline void setNodeNumber(int node)
  {
    nodeNumber_ = node;
  }
  void deactivate(int mode = 3);
  inline bool allActivated() const
  {
    return ((active_ & 7) == 7);
  }
  inline bool marked() const
  {
    return ((active_ & 8) != 0);
  }
  inline void mark()
  {
    active_ |= 8;
  }
  inline void unmark()
  {
    active_ &= ~8;
  }
  inline bool symmetryWorked() const
  {
    return (active_ & 16) != 0;
  }
  inline void setSymmetryWorked()
  {
    active_ |= 16;
  }
 
  inline const OsiBranchingObject *parentBranch() const
  {
    return parentBranch_;
  }
  void unsetParentBasedData();
 
protected:
  int numberPointingToThis_;
 
  CbcNodeInfo *parent_;
 
  OsiBranchingObject *parentBranch_;
 
  CbcNode *owner_;
 
  int numberCuts_;
 
  int nodeNumber_;
 
  CbcCountRowCut **cuts_;
 
  int numberRows_;
 
  int numberBranchesLeft_;
  int active_;
 
private:
  CbcNodeInfo &operator=(const CbcNodeInfo &rhs);
 
  void setParentBasedData();
};
 
#endif // CbcNodeInfo_H
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/