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_;
  }

  /// Number of row cuts (this node)
  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;
  }

  /// Get symmetry value (true worked at this node)
  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
*/