ClpNode.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2008, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef ClpNode_H
#define ClpNode_H
 
#include "CoinPragma.hpp"
 
// This implements all stuff for Clp fathom
 
class ClpFactorization;
class ClpDualRowSteepest;
class ClpNodeStuff;
class ClpNode {
 
public:

  void applyNode(ClpSimplex *model, int doBoundsEtc);
  void chooseVariable(ClpSimplex *model, ClpNodeStuff *info);
  int fixOnReducedCosts(ClpSimplex *model);
  void createArrays(ClpSimplex *model);
  void cleanUpForCrunch();


  inline double objectiveValue() const
  {
    return objectiveValue_;
  }

  inline void setObjectiveValue(double value)
  {
    objectiveValue_ = value;
  }

  inline const double *primalSolution() const
  {
    return primalSolution_;
  }

  inline const double *dualSolution() const
  {
    return dualSolution_;
  }

  inline double branchingValue() const
  {
    return branchingValue_;
  }

  inline double sumInfeasibilities() const
  {
    return sumInfeasibilities_;
  }

  inline int numberInfeasibilities() const
  {
    return numberInfeasibilities_;
  }

  inline int depth() const
  {
    return depth_;
  }

  inline double estimatedSolution() const
  {
    return estimatedSolution_;
  }

  int way() const;
  bool fathomed() const;
  void changeState();
  inline int sequence() const
  {
    return sequence_;
  }

  inline bool oddArraysExist() const
  {
    return lower_ != NULL;
  }

  inline const unsigned char *statusArray() const
  {
    return status_;
  }



  ClpNode();
  ClpNode(ClpSimplex *model, const ClpNodeStuff *stuff, int depth);
  void gutsOfConstructor(ClpSimplex *model, const ClpNodeStuff *stuff,
    int arraysExist, int depth);
  virtual ~ClpNode();


  ClpNode(const ClpNode &);
  ClpNode &operator=(const ClpNode &);
 
protected:
  // For state of branch
  typedef struct {
    unsigned int firstBranch : 1; //  nonzero if first branch on variable is up
    unsigned int branch : 2; //  0 means do first branch next, 1 second, 2 finished
    unsigned int spare : 29;
  } branchState;


  double branchingValue_;
  double objectiveValue_;
  double sumInfeasibilities_;
  double estimatedSolution_;
  ClpFactorization *factorization_;
  ClpDualRowSteepest *weights_;
  unsigned char *status_;
  double *primalSolution_;
  double *dualSolution_;
  int *lower_;
  int *upper_;
  int *pivotVariables_;
  int *fixed_;
  branchState branchState_;
  int sequence_;
  int numberInfeasibilities_;
  int depth_;
  int numberFixed_;
  int flags_;
  int maximumFixed_;
  int maximumRows_;
  int maximumColumns_;
  int maximumIntegers_;
};
class ClpNodeStuff {
 
public:

  ClpNodeStuff();
  virtual ~ClpNodeStuff();


  ClpNodeStuff(const ClpNodeStuff &);
  ClpNodeStuff &operator=(const ClpNodeStuff &);
  void zap(int type);


  void fillPseudoCosts(const double *down, const double *up,
    const int *priority,
    const int *numberDown, const int *numberUp,
    const int *numberDownInfeasible, const int *numberUpInfeasible,
    int number);
  void update(int way, int sequence, double change, bool feasible);
  int maximumNodes() const;
  int maximumSpace() const;
 
public:

  double integerTolerance_;
  double integerIncrement_;
  double smallChange_;
  double *downPseudo_;
  double *upPseudo_;
  int *priority_;
  int *numberDown_;
  int *numberUp_;
  int *numberDownInfeasible_;
  int *numberUpInfeasible_;
  double *saveCosts_;
  ClpNode **nodeInfo_;
  ClpSimplex *large_;
  int *whichRow_;
  int *whichColumn_;
#ifndef NO_FATHOM_PRINT
  CoinMessageHandler *handler_;
#endif
  int nBound_;
  int saveOptions_;
  int solverOptions_;
  int maximumNodes_;
  int numberBeforeTrust_;
  int stateOfSearch_;
  int nDepth_;
  int nNodes_;
  int numberNodesExplored_;
  int numberIterations_;
  int presolveType_;
#ifndef NO_FATHOM_PRINT
  int startingDepth_;
  int nodeCalled_;
#endif
};
class ClpHashValue {
 
public:

  int index(double value) const;
  int addValue(double value);
  inline int numberEntries() const
  {
    return numberHash_;
  }



  ClpHashValue();
  ClpHashValue(ClpSimplex *model);
  virtual ~ClpHashValue();


  ClpHashValue(const ClpHashValue &);
  ClpHashValue &operator=(const ClpHashValue &);
private:

  int hash(double value) const;
  void resize(bool increaseMax);
 
protected:

  // for hashing
  typedef struct {
    double value;
    int index, next;
  } CoinHashLink;

  mutable CoinHashLink *hash_;
  int numberHash_;
  int maxHash_;
  int lastUsed_;
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/