/home/coin/SVN-release/CoinAll-1.1.0/Blis/src/BlisConGenerator.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the BiCePS Linear Integer Solver (BLIS).             *
 *                                                                           *
 * BLIS is distributed under the Common Public License as part of the        *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           * 
 *                                                                           *
 * Copyright (C) 2001-2007, Lehigh University, Yan Xu, and Ted Ralphs.       *
 * All Rights Reserved.                                                      *
 *===========================================================================*/


//#############################################################################
// This file is modified from COIN/Cbc/CbcCutGenerator.hpp
//#############################################################################


#ifndef BlisConGenerator_h_
#define BlisConGenerator_h_

#include "OsiSolverInterface.hpp"
#include "OsiCuts.hpp"


class BlisModel;

class OsiRowCut;
class OsiRowCutDebugger;
class CglCutGenerator;


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

class BlisConGenerator  {

protected:
    BlisModel *model_;
    
    CglCutGenerator * generator_;

    //------------------------------------------------------
    // CON CONTROL
    //------------------------------------------------------

    BlisCutStrategy strategy_;

    int cutGenerationFrequency_;
    
    std::string name_;
    
    bool normal_;
    
    bool atSolution_;

    bool whenInfeasible_;
    
    //------------------------------------------------------
    // CON STATISTICS
    //------------------------------------------------------
    
    int numConsGenerated_;
    
    int numConsUsed_;
    
    double time_;
    
    int calls_;

    int noConsCalls_;
    
 public:

    BlisConGenerator()
        :
        model_(NULL),
        generator_(NULL),
        strategy_(BlisCutStrategyAuto),
        cutGenerationFrequency_(1),
        normal_(true),
        atSolution_(false),
        whenInfeasible_(false),
        numConsGenerated_(0),
        numConsUsed_(0),
        time_(0),
        calls_(0),
        noConsCalls_(0)
        { name_ = "UNKNOWN"; }
    
    BlisConGenerator(BlisModel * model,
                     CglCutGenerator * generator,
                     const char * name = NULL,
                     BlisCutStrategy strategy = BlisCutStrategyAuto,
                     int cutGenerationFrequency_ = 1,
                     bool normal = true, 
                     bool atSolution = false, 
                     bool infeasible = false);
    
    BlisConGenerator (const BlisConGenerator &);
    
    BlisConGenerator & operator=(const BlisConGenerator& rhs);
    
    virtual ~BlisConGenerator()
        {
            if (generator_) {
                delete generator_;
                generator_ = NULL;
            }
        }
    
    virtual bool generateConstraints(BcpsConstraintPool &conPool); 

    inline BlisModel *getModel() { return model_; }

    inline void setModel(BlisModel *m) { model_ = m; }
    
    void refreshModel(BlisModel * model);
    
    void setName(const char *str) { name_ = str; }
    
    inline std::string name() const { return name_; }
    
    void setStrategy(BlisCutStrategy value) { strategy_ = value; }
    
    inline BlisCutStrategy strategy() const { return strategy_; }
    
    void setCutGenerationFreq(int freq) { cutGenerationFrequency_ = freq; }
    
    inline int cutGenerationFreq() const { return cutGenerationFrequency_; }
    
    inline bool normal() const { return normal_; }
    
    inline void setNormal(bool value) { normal_ = value; }
    
    inline bool atSolution() const { return atSolution_; }
    
    inline void setAtSolution(bool value) { atSolution_ = value; }

    inline bool whenInfeasible() const { return whenInfeasible_; }
    
    inline void setWhenInfeasible(bool value) { whenInfeasible_ = value; }
    
    inline CglCutGenerator * generator() const { return generator_; }
    
    inline int numConsGenerated() { return numConsGenerated_; }

    inline void addNumConsGenerated(int n) { numConsGenerated_ += n; }
    
    inline int numConsUsed() { return numConsUsed_; }
    
    inline void addNumConsUsed(int n) { numConsUsed_ += n; }

    inline double time() const { return time_; }
    
    inline void addTime(double t) { time_ += t; }
    
    inline int calls() const { return calls_; }

    inline void addCalls(int n=1) { calls_ += n; }

    inline int noConsCalls() const { return noConsCalls_; }

    inline void addNoConsCalls(int n=1) { noConsCalls_ += n; }
};

#endif

---