CbcStrategy.hpp

Go to the documentation of this file.

/* $Id: CbcStrategy.hpp 1573 2011-01-05 01:12:36Z lou $ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcStrategy_H
#define CbcStrategy_H
 
#include "CbcModel.hpp"
class CglPreProcess;
class CbcNodeInfo;
class CbcNode;
class CoinWarmStartDiff;
 
//#############################################################################
class CbcStrategy {
public:
    // Default Constructor
    CbcStrategy ();
 
    virtual ~CbcStrategy();
 
    virtual CbcStrategy * clone() const = 0;
 
    virtual void setupCutGenerators(CbcModel & model) = 0;
    virtual void setupHeuristics(CbcModel & model) = 0;
    virtual void setupPrinting(CbcModel & model, int modelLogLevel) = 0;
    virtual void setupOther(CbcModel & model) = 0;
    inline void setNested(int depth) {
        depth_ = depth;
    }
    inline int getNested() const {
        return depth_;
    }
    inline void setPreProcessState(int state) {
        preProcessState_ = state;
    }
    inline int preProcessState() const {
        return preProcessState_;
    }
    inline CglPreProcess * process() const {
        return process_;
    }
    void deletePreProcess();
    virtual CbcNodeInfo * fullNodeInfo(CbcModel * model, int numberRowsAtContinuous) const;
    virtual CbcNodeInfo * partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
                                          int numberChangedBounds, const int * variables,
                                          const double * boundChanges,
                                          const CoinWarmStartDiff *basisDiff) const;
    virtual void generateCpp( FILE * ) {}
    virtual int status(CbcModel * model, CbcNodeInfo * parent, int whereFrom);
private:
 
    CbcStrategy & operator=(const CbcStrategy& rhs);
protected:
    // Data
    int depth_;
    int preProcessState_;
    CglPreProcess * process_;
};
 
class CbcStrategyNull : public CbcStrategy {
public:
 
    // Default Constructor
    CbcStrategyNull () {}
 
    // Copy constructor
    CbcStrategyNull ( const CbcStrategyNull & rhs) : CbcStrategy(rhs) {}
 
    // Destructor
    ~CbcStrategyNull () {}
 
    virtual CbcStrategy * clone() const {
        return new CbcStrategyNull(*this);
    }
 
    virtual void setupCutGenerators(CbcModel & ) {}
    virtual void setupHeuristics(CbcModel & ) {}
    virtual void setupPrinting(CbcModel & , int ) {}
    virtual void setupOther(CbcModel & ) {}
 
protected:
    // Data
private:
    CbcStrategyNull & operator=(const CbcStrategyNull& rhs);
};
 
class CbcStrategyDefault : public CbcStrategy {
public:
 
    // Default Constructor
    CbcStrategyDefault (int cutsOnlyAtRoot = 1,
                        int numberStrong = 5,
                        int numberBeforeTrust = 0,
                        int printLevel = 0);
 
    // Copy constructor
    CbcStrategyDefault ( const CbcStrategyDefault &);
 
    // Destructor
    ~CbcStrategyDefault ();
 
    virtual CbcStrategy * clone() const;
 
    virtual void setupCutGenerators(CbcModel & model);
    virtual void setupHeuristics(CbcModel & model);
    virtual void setupPrinting(CbcModel & model, int modelLogLevel) ;
    virtual void setupOther(CbcModel & model);
    inline void setupPreProcessing(int desired = 1, int passes = 10) {
        desiredPreProcess_ = desired;
        preProcessPasses_ = passes;
    }
    inline int desiredPreProcess() const {
        return desiredPreProcess_;
    }
    inline int preProcessPasses() const {
        return preProcessPasses_;
    }
    virtual void generateCpp( FILE * fp) ;
 
protected:
    // Data
 
    // Whether to do cuts only at root (-1 -> switch off totally)
    int cutsOnlyAtRoot_;
 
    // How much strong branching to do
    int numberStrong_;
 
    // Number branches needed to trust with dynamic pseudo costs
    int numberBeforeTrust_;
 
    // Print level 0 little, 1 medium
    int printLevel_;
 
    int desiredPreProcess_;
    int preProcessPasses_;
 
private:
    CbcStrategyDefault & operator=(const CbcStrategyDefault& rhs);
};
 
 
class CbcStrategyDefaultSubTree : public CbcStrategy {
public:
 
    // Default Constructor
    CbcStrategyDefaultSubTree (CbcModel * parent = NULL, int cutsOnlyAtRoot = 1,
                               int numberStrong = 5,
                               int numberBeforeTrust = 0,
                               int printLevel = 0);
 
    // Copy constructor
    CbcStrategyDefaultSubTree ( const CbcStrategyDefaultSubTree &);
 
    // Destructor
    ~CbcStrategyDefaultSubTree ();
 
    virtual CbcStrategy * clone() const;
 
    virtual void setupCutGenerators(CbcModel & model);
    virtual void setupHeuristics(CbcModel & model);
    virtual void setupPrinting(CbcModel & model, int modelLogLevel) ;
    virtual void setupOther(CbcModel & model);
protected:
    // Data
    // Parent model
    CbcModel * parentModel_;
    // Whether to do cuts only at root (-1 -> switch off totally)
    int cutsOnlyAtRoot_;
 
    // How much strong branching to do
    int numberStrong_;
 
    // Number branches needed to trust with dynamic pseudo costs
    int numberBeforeTrust_;
 
    // Print level 0 little, 1 medium
    int printLevel_;
 
private:
    CbcStrategyDefaultSubTree & operator=(const CbcStrategyDefaultSubTree& rhs);
};
 
 
#endif