CbcTree.hpp

Go to the documentation of this file.

/* $Id: CbcTree.hpp 1393 2009-12-11 00:29:38Z lou $ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcTree_H
#define CbcTree_H

#include <vector>
#include <algorithm>
#include <cmath>

#include "CoinFinite.hpp"
#include "CoinHelperFunctions.hpp"
#include "CbcCompare.hpp"

//#define CBC_DUBIOUS_HEAP
#if defined(_MSC_VER) || defined(__MNO_CYGWIN)
//#define CBC_DUBIOUS_HEAP
#endif
#ifndef CBC_DUBIOUS_HEAP
class CbcTree {

public:

    // Default Constructor
    CbcTree ();

    // Copy constructor
    CbcTree ( const CbcTree & rhs);
    // = operator
    CbcTree & operator=(const CbcTree & rhs);

    virtual ~CbcTree();

    virtual CbcTree * clone() const;
    virtual void generateCpp( FILE * ) {}


    void setComparison(CbcCompareBase  &compare);

    virtual CbcNode * top() const;

    virtual void push(CbcNode * x);

    virtual void pop() ;
    virtual CbcNode * bestNode(double cutoff);



    virtual bool empty() ;

    virtual int size() const {
        return nodes_.size();
    }
    inline CbcNode * operator [] (int i) const {
        return nodes_[i];
    }

    inline CbcNode * nodePointer (int i) const {
        return nodes_[i];
    }




    virtual void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);

    CbcNode * bestAlternate();

    virtual void endSearch() {}

    virtual double getBestPossibleObjective();
    inline void resetNodeNumbers() {
        maximumNodeNumber_ = 0;
    }
    inline int maximumNodeNumber() const {
        return maximumNodeNumber_;
    }
    inline void setNumberBranching(int value) {
        numberBranching_ = value;
    }
    inline int getNumberBranching() const {
        return numberBranching_;
    }
    inline void setMaximumBranching(int value) {
        maximumBranching_ = value;
    }
    inline int getMaximumBranching() const {
        return maximumBranching_;
    }
    inline unsigned int * branched() const {
        return branched_;
    }
    inline int * newBounds() const {
        return newBound_;
    }
    void addBranchingInformation(const CbcModel * model, const CbcNodeInfo * nodeInfo,
                                 const double * currentLower,
                                 const double * currentUpper);
    void increaseSpace();
protected:
    std::vector <CbcNode *> nodes_;
    CbcCompare comparison_;     
    int maximumNodeNumber_;
    int numberBranching_;
    int maximumBranching_;
    unsigned int * branched_;
    int * newBound_;
};
#ifdef JJF_ZERO // not used
class CbcTreeArray : public CbcTree {

public:

    // Default Constructor
    CbcTreeArray ();

    // Copy constructor
    CbcTreeArray ( const CbcTreeArray & rhs);
    // = operator
    CbcTreeArray & operator=(const CbcTreeArray & rhs);

    virtual ~CbcTreeArray();

    virtual CbcTree * clone() const;
    virtual void generateCpp( FILE * ) {}


    void setComparison(CbcCompareBase  &compare);

    virtual void push(CbcNode * x);

    virtual CbcNode * bestNode(double cutoff);



    virtual bool empty() ;



    void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
    virtual double getBestPossibleObjective();
protected:
    CbcNode * lastNode_;
    CbcNode * lastNodePopped_;
    int switches_;

};

#include "CoinSearchTree.hpp"
class CbcNewTree : public CbcTree, public CoinSearchTreeManager {

public:

    // Default Constructor
    CbcNewTree ();

    // Copy constructor
    CbcNewTree ( const CbcNewTree & rhs);
    // = operator
    CbcNewTree & operator=(const CbcNewTree & rhs);

    virtual ~CbcNewTree();

    virtual CbcNewTree * clone() const;
    virtual void generateCpp( FILE * ) {}


    void setComparison(CbcCompareBase  &compare);

    virtual CbcNode * top() const;

    virtual void push(CbcNode * x);

    virtual void pop() ;
    virtual CbcNode * bestNode(double cutoff);



    virtual bool empty() ;

    inline int size() const {
        return nodes_.size();
    }

    inline CbcNode * operator [] (int i) const {
        return nodes_[i];
    }

    inline CbcNode * nodePointer (int i) const {
        return nodes_[i];
    }



    void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);

    CbcNode * bestAlternate();

    virtual void endSearch() {}
protected:


};
#endif
#else
class CbcTree {

public:

    // Default Constructor
    CbcTree ();

    // Copy constructor
    CbcTree ( const CbcTree & rhs);
    // = operator
    CbcTree & operator=(const CbcTree & rhs);

    virtual ~CbcTree();

    virtual CbcTree * clone() const;
    virtual void generateCpp( FILE * fp) {}


    void setComparison(CbcCompareBase  &compare);

    virtual CbcNode * top() const;

    virtual void push(CbcNode * x);

    virtual void pop() ;
    virtual CbcNode * bestNode(double cutoff);



    //virtual bool empty() ;

    inline int size() const {
        return nodes_.size();
    }

    inline CbcNode * operator [] (int i) const {
        return nodes_[i];
    }

    inline CbcNode * nodePointer (int i) const {
        return nodes_[i];
    }

    virtual bool empty();
    //inline int size() const { return size_; }
    void realpop();
    void fixTop();
    void realpush(CbcNode * node);


    void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);

    CbcNode * bestAlternate();

    virtual void endSearch() {}
    inline void resetNodeNumbers() {
        maximumNodeNumber_ = 0;
    }
protected:
    std::vector <CbcNode *> nodes_;
    CbcCompare comparison_;     
    int maximumNodeNumber_;


};
#endif
#endif