ClpNode.hpp

Go to the documentation of this file.

/* $Id: ClpNode.hpp 1910 2013-01-27 02:00:13Z stefan $ */
// 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