BlisConGenerator.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Bcps Linear Solver (BLIS).                       *
 *                                                                           *
 * BLIS is distributed under the Eclipse 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-2013, 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  {

 private:
    BlisModel *model_;
    
    CglCutGenerator * generator_;

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

    int strategy_;
    
    char * 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_(-1),
        name_(NULL),
        normal_(true),
        atSolution_(false),
        whenInfeasible_(false),
        numConsGenerated_(0),
        numConsUsed_(0),
        time_(0),
        calls_(0),
        noConsCalls_(0)
        {}
    
    BlisConGenerator(BlisModel * model,
                     CglCutGenerator * generator,
                     const char * name = NULL,
                     int strategy = 0,
                     bool normal = true, 
                     bool atSolution = false, 
                     bool infeasible = false);
    
    BlisConGenerator (const BlisConGenerator &);
    
    BlisConGenerator & operator=(const BlisConGenerator& rhs);
    
    ~BlisConGenerator()
        {
            free(name_);
            name_= NULL;
            if (generator_) {
                delete generator_;
                generator_ = NULL;
            }
        }
    
    bool generateCons(OsiCuts &cs, bool fullScan); 

    void refreshModel(BlisModel * model);
    
    inline const char * name() const { return name_; }
    
    void setStrategy(int value) { strategy_ = value; }
    
    inline int strategy() const { return strategy_; }
    
    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() { return time_; }
    
    inline void addTime(double t) { time_ += t; }
    
    inline int calls() { return calls_; }

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

    inline int noConsCalls() { return noConsCalls_; }

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

#endif