/home/coin/SVN-release/CoinAll-1.1.0/Blis/src/BlisHeuristic.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/CbcHeuristic.hpp
//#############################################################################


#ifndef BlisHeuristic_h_
#define BlisHeuristic_h_

#include <string>
#include <vector>

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

#include "Blis.h"

class BlisModel;


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


class BlisHeuristic {

 private:

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

    BlisModel *model_;
    
    char *name_;
    
    BlisHeurStrategy strategy_;

    int heurCallFrequency_;
    
    int numSolutions_;

    double time_;

    int calls_;

    int noSolsCalls_;
    
public:
    
    BlisHeuristic() {
        model_ = NULL;
        name_ = strdup("Unknown");
        strategy_ = BlisHeurStrategyAuto;
        heurCallFrequency_ = 1;
        numSolutions_ = 0;
        time_ = 0.0;
        calls_ = 0;
        noSolsCalls_ = 0;
    }
    
    BlisHeuristic(BlisModel *model, const char *name,
                  BlisHeurStrategy strategy, int heurCallFrequency) {
        model_ = model;
        if (name) {
            name_ = strdup(name);
        }
        else {
            name_ = strdup("Unknown");
        }
        strategy_ = strategy;
        heurCallFrequency_ = heurCallFrequency;
        numSolutions_ = 0;
        time_ = 0.0;
        calls_ = 0;
        noSolsCalls_ = 0;
    }

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

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

    virtual void setHeurCallFrequency(int freq) { heurCallFrequency_ = freq; }
    virtual int heurCallFrequency() const { return heurCallFrequency_; }
    //@]

    virtual BlisHeuristic * clone() const {
        BlisHeuristic *h = NULL;
        assert(0);
        return h;
    };
    
    virtual bool searchSolution(double & objectiveValue, 
                               double * newSolution)=0;
    
    virtual bool searchSolution(double & objectiveValue,
                               double * newSolution,
                               OsiCuts & cs) { return 0; }
    
    inline const char * name() const { return name_; }
    
    inline void addNumSolutions(int num=1) { numSolutions_ += num; }

    inline int numSolutions() const { return numSolutions_; }
    
    inline void addTime(double t=0.0) { time_ += t; }

    inline double time() const { return time_; }
    
    inline void addCalls(int c=1) { calls_ += c; }
    
    inline int calls() const { return calls_; } 

    inline int noSolCalls() const { return noSolsCalls_; }

    inline void addNoSolCalls(int n=1) { noSolsCalls_ += n; }
};

#endif

---