CbcCutGenerator.hpp

Go to the documentation of this file.

/* $Id: CbcCutGenerator.hpp 2081 2014-09-25 11:31:17Z forrest $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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 void setMaximumTries(int value)
    { maximumTries_ = value;}
    inline int maximumTries() const
    { return maximumTries_;}
 
    inline int switches() const {
        return switches_;
    }
    inline void setSwitches(int value) {
        switches_ = value;
    }
    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 bool whetherInMustCallAgainMode() const {
        return (switches_&2048) != 0;
    }
    inline void setWhetherInMustCallAgainMode(bool yesNo) {
        switches_ &= ~2048;
        switches_ |= yesNo ? 2048 : 0;
    }
    inline bool whetherCallAtEnd() const {
        return (switches_&4096) != 0;
    }
    inline void setWhetherCallAtEnd(bool yesNo) {
        switches_ &= ~4096;
        switches_ |= yesNo ? 4096 : 0;
    }
    inline bool needsRefresh() const {
        return (switches_&8192) != 0;
    }
    inline void setNeedsRefresh(bool yesNo) {
        switches_ &= ~8192;
        switches_ |= yesNo ? 8192 : 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 setNumberShortCutsAtRoot(int value) {
        numberShortCutsAtRoot_ = value;
    }
    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;
    }
    void addStatistics(const CbcCutGenerator * other);
    void scaleBackStatistics(int factor);
 
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_;
    int maximumTries_;
};
 
// 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