CbcCutGenerator.hpp

Go to the documentation of this file.

/* $Id: CbcCutGenerator.hpp 1432 2010-02-07 19:33:53Z bjarni $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcCutGenerator_H
#define CbcCutGenerator_H

#include "OsiSolverInterface.hpp"
#include "OsiCuts.hpp"
#include "CglCutGenerator.hpp"
#include "CbcCutModifier.hpp"

class CbcModel;
class OsiRowCut;
class OsiRowCutDebugger;

//#############################################################################

class CbcCutGenerator  {

public:

    bool generateCuts( OsiCuts &cs, int fullScan, OsiSolverInterface * solver,
                       CbcNode * node);


    CbcCutGenerator ();

    CbcCutGenerator(CbcModel * model, CglCutGenerator * generator,
                    int howOften = 1, const char * name = NULL,
                    bool normal = true, bool atSolution = false,
                    bool infeasible = false, int howOftenInsub = -100,
                    int whatDepth = -1, int whatDepthInSub = -1, int switchOffIfLessThan = 0);

    CbcCutGenerator (const CbcCutGenerator &);

    CbcCutGenerator & operator=(const CbcCutGenerator& rhs);

    ~CbcCutGenerator ();

    void refreshModel(CbcModel * model);

    inline const char * cutGeneratorName() const {
        return generatorName_;
    }

    void generateTuning( FILE * fp);
    void setHowOften(int value) ;

    inline int howOften() const {
        return whenCutGenerator_;
    }
    inline int howOftenInSub() const {
        return whenCutGeneratorInSub_;
    }
    inline int inaccuracy() const {
        return inaccuracy_;
    }
    inline void setInaccuracy(int level) {
        inaccuracy_ = level;
    }

    void setWhatDepth(int value) ;
    void setWhatDepthInSub(int value) ;
    inline int whatDepth() const {
        return depthCutGenerator_;
    }
    inline int whatDepthInSub() const {
        return depthCutGeneratorInSub_;
    }

    inline bool normal() const {
        return (switches_&1) != 0;
    }
    inline void setNormal(bool value) {
        switches_ &= ~1;
        switches_ |= value ? 1 : 0;
    }
    inline bool atSolution() const {
        return (switches_&2) != 0;
    }
    inline void setAtSolution(bool value) {
        switches_ &= ~2;
        switches_ |= value ? 2 : 0;
    }
    inline bool whenInfeasible() const {
        return (switches_&4) != 0;
    }
    inline void setWhenInfeasible(bool value) {
        switches_ &= ~4;
        switches_ |= value ? 4 : 0;
    }
    inline bool timing() const {
        return (switches_&64) != 0;
    }
    inline void setTiming(bool value) {
        switches_ &= ~64;
        switches_ |= value ? 64 : 0;
        timeInCutGenerator_ = 0.0;
    }
    inline double timeInCutGenerator() const {
        return timeInCutGenerator_;
    }
    inline void incrementTimeInCutGenerator(double value) {
        timeInCutGenerator_ += value;
    }
    inline CglCutGenerator * generator() const {
        return generator_;
    }
    inline int numberTimesEntered() const {
        return numberTimes_;
    }
    inline void setNumberTimesEntered(int value) {
        numberTimes_ = value;
    }
    inline void incrementNumberTimesEntered(int value = 1) {
        numberTimes_ += value;
    }
    inline int numberCutsInTotal() const {
        return numberCuts_;
    }
    inline void setNumberCutsInTotal(int value) {
        numberCuts_ = value;
    }
    inline void incrementNumberCutsInTotal(int value = 1) {
        numberCuts_ += value;
    }
    inline int numberElementsInTotal() const {
        return numberElements_;
    }
    inline void setNumberElementsInTotal(int value) {
        numberElements_ = value;
    }
    inline void incrementNumberElementsInTotal(int value = 1) {
        numberElements_ += value;
    }
    inline int numberColumnCuts() const {
        return numberColumnCuts_;
    }
    inline void setNumberColumnCuts(int value) {
        numberColumnCuts_ = value;
    }
    inline void incrementNumberColumnCuts(int value = 1) {
        numberColumnCuts_ += value;
    }
    inline int numberCutsActive() const {
        return numberCutsActive_;
    }
    inline void setNumberCutsActive(int value) {
        numberCutsActive_ = value;
    }
    inline void incrementNumberCutsActive(int value = 1) {
        numberCutsActive_ += value;
    }
    inline void setSwitchOffIfLessThan(int value) {
        switchOffIfLessThan_ = value;
    }
    inline int switchOffIfLessThan() const {
        return switchOffIfLessThan_;
    }
    inline bool needsOptimalBasis() const {
        return (switches_&128) != 0;
    }
    inline void setNeedsOptimalBasis(bool yesNo) {
        switches_ &= ~128;
        switches_ |= yesNo ? 128 : 0;
    }
    inline bool mustCallAgain() const {
        return (switches_&8) != 0;
    }
    inline void setMustCallAgain(bool yesNo) {
        switches_ &= ~8;
        switches_ |= yesNo ? 8 : 0;
    }
    inline bool switchedOff() const {
        return (switches_&16) != 0;
    }
    inline void setSwitchedOff(bool yesNo) {
        switches_ &= ~16;
        switches_ |= yesNo ? 16 : 0;
    }
    inline bool ineffectualCuts() const {
        return (switches_&512) != 0;
    }
    inline void setIneffectualCuts(bool yesNo) {
        switches_ &= ~512;
        switches_ |= yesNo ? 512 : 0;
    }
    inline bool whetherToUse() const {
        return (switches_&1024) != 0;
    }
    inline void setWhetherToUse(bool yesNo) {
        switches_ &= ~1024;
        switches_ |= yesNo ? 1024 : 0;
    }
    inline int numberCutsAtRoot() const {
        return numberCutsAtRoot_;
    }
    inline void setNumberCutsAtRoot(int value) {
        numberCutsAtRoot_ = value;
    }
    inline int numberActiveCutsAtRoot() const {
        return numberActiveCutsAtRoot_;
    }
    inline void setNumberActiveCutsAtRoot(int value) {
        numberActiveCutsAtRoot_ = value;
    }
    inline int numberShortCutsAtRoot() const {
        return numberShortCutsAtRoot_;
    }
    inline void setModel(CbcModel * model) {
        model_ = model;
    }
    inline bool globalCutsAtRoot() const {
        return (switches_&32) != 0;
    }
    inline void setGlobalCutsAtRoot(bool yesNo) {
        switches_ &= ~32;
        switches_ |= yesNo ? 32 : 0;
    }
    inline bool globalCuts() const {
        return (switches_&256) != 0;
    }
    inline void setGlobalCuts(bool yesNo) {
        switches_ &= ~256;
        switches_ |= yesNo ? 256 : 0;
    }

private:

    OsiCuts savedCuts_;
    double timeInCutGenerator_;
    CbcModel *model_;

    // The CglCutGenerator object
    CglCutGenerator * generator_;

    char * generatorName_;

    int whenCutGenerator_;
    int whenCutGeneratorInSub_;
    int switchOffIfLessThan_;

    int depthCutGenerator_;

    int depthCutGeneratorInSub_;

    int inaccuracy_;
    int numberTimes_;
    int numberCuts_;
    int numberElements_;
    int numberColumnCuts_;
    int numberCutsActive_;
    int numberCutsAtRoot_;
    int numberActiveCutsAtRoot_;
    int numberShortCutsAtRoot_;
    int switches_;
};

// How often to do if mostly switched off (A)
# define SCANCUTS 1000
// How often to do if mostly switched off (probing B)
# define SCANCUTS_PROBING 1000

#endif