BlisHeuristic.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                             *
 *                                                                           * 
 *                                                                           *
 * Corporation, Lehigh University, Yan Xu, Ted Ralphs, Matthew Salzman and   *
 * others. All Rights Reserved.                                              *
 *===========================================================================*/


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


#ifndef BlisHeuristic_h_
#define BlisHeuristic_h_

#include <string>
#include <vector>

#include "CoinPackedMatrix.hpp"
#include "OsiCuts.hpp"

class BlisModel;


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


class BlisHeuristic {

 private:

    BlisHeuristic & operator = (const BlisHeuristic& rhs);
    
 protected:

    BlisModel *model_;
    
    char *name_;
    
    int strategy_;

    int numSolutions_;

    double time_;

    int calls_;
    
 public:

    BlisHeuristic() {
        model_ = NULL;
        name_ = strdup("Unknown");
        strategy_ = 0;
        numSolutions_ = 0;
        time_ = 0.0;
        calls_ = 0;
    }
    
    BlisHeuristic(BlisModel *model, const char *name, int strategy) {
        model_ = model;
        if (name) {
            name_ = strdup(name);
        }
        else {
            name_ = strdup("Unknown");
        }
        strategy_ = strategy;
        numSolutions_ = 0;
        time_ = 0.0;
        calls_ = 0;
    }

    virtual ~BlisHeuristic() { if (name_) free(name_); }

    BlisHeuristic(const BlisHeuristic & rhs) {        
        model_ = rhs.model_;
        name_ = strdup(rhs.name_);
        strategy_ = rhs.strategy_; // What if disabled?
        numSolutions_ = 0;
        time_ = 0.0;
        calls_ = 0;
    }
 
    virtual void setModel(BlisModel * model) { model_ = model ;}
    
    virtual void setStrategy(int strategy) { strategy_ = strategy; }
    virtual int strategy() { return strategy_; }
    //@]

    virtual BlisHeuristic * clone() const = 0;
    
    virtual bool searchSolution(double & objectiveValue, 
                                double * newSolution)=0;
    
    virtual int searchSolution(double & objectiveValue,
                               double * newSolution,
                               OsiCuts & cs) { return 0; }
    
    int numSolutions() { return numSolutions_; }
    
    inline double time() { return time_; }
    
    inline int calls() { return calls_; }
};

#endif