CbcNode.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).
 
#ifndef CbcNode_H
#define CbcNode_H
 
#include <string>
#include <vector>
 
#include "CoinWarmStartBasis.hpp"
#include "CoinSearchTree.hpp"
#include "CbcBranchBase.hpp"
#include "CbcNodeInfo.hpp"
#include "CbcFullNodeInfo.hpp"
#include "CbcPartialNodeInfo.hpp"
 
class OsiSolverInterface;
class OsiSolverBranch;
 
class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinWarmStartBasis;
class CbcCountRowCut;
class CbcModel;
class CbcNode;
class CbcSubProblem;
class CbcGeneralBranchingObject;

 
class CbcNode : public CoinTreeNode {
 
public:
  CbcNode();

  CbcNode(CbcModel *model, CbcNode *lastNode);

  CbcNode(const CbcNode &);

  CbcNode &operator=(const CbcNode &rhs);

  ~CbcNode();

  void
  createInfo(CbcModel *model,
    CbcNode *lastNode,
    const CoinWarmStartBasis *lastws,
    const double *lastLower, const double *lastUpper,
    int numberOldActiveCuts, int numberNewCuts);

  int chooseBranch(CbcModel *model,
    CbcNode *lastNode,
    int numberPassesLeft);
  int chooseDynamicBranch(CbcModel *model,
    CbcNode *lastNode,
    OsiSolverBranch *&branches,
    int numberPassesLeft);
  int chooseOsiBranch(CbcModel *model,
    CbcNode *lastNode,
    OsiBranchingInformation *usefulInfo,
    int branchState);
  int chooseClpBranch(CbcModel *model,
    CbcNode *lastNode);
  int analyze(CbcModel *model, double *results);
  void decrementCuts(int change = 1);

  void decrementParentCuts(CbcModel *model, int change = 1);

  void nullNodeInfo();
  void initializeInfo();

  int branch(OsiSolverInterface *solver);

  double checkIsCutoff(double cutoff);
  // Information to make basis and bounds
  inline CbcNodeInfo *nodeInfo() const
  {
    return nodeInfo_;
  }
 
  // Objective value
  inline double objectiveValue() const
  {
    return objectiveValue_;
  }
  inline void setObjectiveValue(double value)
  {
    objectiveValue_ = value;
  }

  inline int numberBranches() const
  {
    if (branch_)
      return (branch_->numberBranches());
    else
      return (-1);
  }
 
  /* Active arm of the attached OsiBranchingObject.
 
     In the simplest instance, coded -1 for the down arm of the branch, +1 for
     the up arm. But see OsiBranchingObject::way()
       Use nodeInfo--.numberBranchesLeft_ to see how active
    */
  int way() const;
  inline int depth() const
  {
    return depth_;
  }

  inline void setDepth(int value)
  {
    depth_ = value;
  }

  inline int numberUnsatisfied() const
  {
    return numberUnsatisfied_;
  }

  inline void setNumberUnsatisfied(int value)
  {
    numberUnsatisfied_ = value;
  }

  inline double sumInfeasibilities() const
  {
    return sumInfeasibilities_;
  }

  inline void setSumInfeasibilities(double value)
  {
    sumInfeasibilities_ = value;
  }
  // Guessed objective value (for solution)
  inline double guessedObjectiveValue() const
  {
    return guessedObjectiveValue_;
  }
  inline void setGuessedObjectiveValue(double value)
  {
    guessedObjectiveValue_ = value;
  }

  inline const OsiBranchingObject *branchingObject() const
  {
    return branch_;
  }

  inline OsiBranchingObject *modifiableBranchingObject() const
  {
    return branch_;
  }

  inline void setBranchingObject(OsiBranchingObject *branchingObject)
  {
    branch_ = branchingObject;
  }

  inline int nodeNumber() const
  {
    return nodeNumber_;
  }
  inline void setNodeNumber(int node)
  {
    nodeNumber_ = node;
  }

  inline bool onTree() const
  {
    return (state_ & 1) != 0;
  }

  inline void setOnTree(bool yesNo)
  {
    if (yesNo)
      state_ |= 1;
    else
      state_ &= ~1;
  }

  inline bool active() const
  {
    return (state_ & 2) != 0;
  }

  inline void setActive(bool yesNo)
  {
    if (yesNo)
      state_ |= 2;
    else
      state_ &= ~2;
  }

  inline int getState() const
  {
    return state_;
  }

  inline void setState(int value)
  {
    state_ = value;
  }

  void print() const;
  inline void checkInfo() const
  {
    assert(nodeInfo_->numberBranchesLeft() == branch_->numberBranchesLeft());
  }
 
private:
  // Data
  CbcNodeInfo *nodeInfo_;
  double objectiveValue_;
  double guessedObjectiveValue_;
  double sumInfeasibilities_;
  OsiBranchingObject *branch_;
  int depth_;
  int numberUnsatisfied_;
  int nodeNumber_;
  int state_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/