CbcStrategy.hpp

Go to the documentation of this file.

/* $Id: CbcStrategy.hpp 1432 2010-02-07 19:33:53Z bjarni $ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
#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