CbcHeuristicFPump.hpp

Go to the documentation of this file.

/* $Id: CbcHeuristicFPump.hpp 1432 2010-02-07 19:33:53Z bjarni $ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcHeuristicFeasibilityPump_H
#define CbcHeuristicFeasibilityPump_H

#include "CbcHeuristic.hpp"
#include "OsiClpSolverInterface.hpp"

class CbcHeuristicFPump : public CbcHeuristic {
public:

    // Default Constructor
    CbcHeuristicFPump ();

    // Constructor with model - assumed before cuts
    CbcHeuristicFPump (CbcModel & model,
                       double downValue = 0.5, bool roundExpensive = false);

    // Copy constructor
    CbcHeuristicFPump ( const CbcHeuristicFPump &);

    // Destructor
    ~CbcHeuristicFPump ();

    CbcHeuristicFPump & operator=(const CbcHeuristicFPump& rhs);
    virtual CbcHeuristic * clone() const;
    virtual void generateCpp( FILE * fp) ;

    virtual void resetModel(CbcModel * model);

    virtual void setModel(CbcModel * model);

    using CbcHeuristic::solution ;
    virtual int solution(double & objectiveValue,
                         double * newSolution);

    void setMaximumTime(double value);
    inline double maximumTime() const {
        return maximumTime_;
    }
    inline void setFakeCutoff(double value) {
        fakeCutoff_ = value;
    }
    inline double fakeCutoff() const {
        return fakeCutoff_;
    }
    inline void setAbsoluteIncrement(double value) {
        absoluteIncrement_ = value;
    }
    inline double absoluteIncrement() const {
        return absoluteIncrement_;
    }
    inline void setRelativeIncrement(double value) {
        relativeIncrement_ = value;
    }
    inline double relativeIncrement() const {
        return relativeIncrement_;
    }
    inline void setDefaultRounding(double value) {
        defaultRounding_ = value;
    }
    inline double defaultRounding() const {
        return defaultRounding_;
    }
    inline void setInitialWeight(double value) {
        initialWeight_ = value;
    }
    inline double initialWeight() const {
        return initialWeight_;
    }
    inline void setWeightFactor(double value) {
        weightFactor_ = value;
    }
    inline double weightFactor() const {
        return weightFactor_;
    }
    inline void setArtificialCost(double value) {
        artificialCost_ = value;
    }
    inline double artificialCost() const {
        return artificialCost_;
    }
    inline double iterationRatio() const {
        return iterationRatio_;
    }
    inline void setIterationRatio(double value) {
        iterationRatio_ = value;
    }
    inline void setMaximumPasses(int value) {
        maximumPasses_ = value;
    }
    inline int maximumPasses() const {
        return maximumPasses_;
    }
    inline void setMaximumRetries(int value) {
        maximumRetries_ = value;
    }
    inline int maximumRetries() const {
        return maximumRetries_;
    }
    inline void setAccumulate(int value) {
        accumulate_ = value;
    }
    inline int accumulate() const {
        return accumulate_;
    }
    inline void setFixOnReducedCosts(int value) {
        fixOnReducedCosts_ = value;
    }
    inline int fixOnReducedCosts() const {
        return fixOnReducedCosts_;
    }
    inline void setReducedCostMultiplier(double value) {
        reducedCostMultiplier_ = value;
    }
    inline double reducedCostMultiplier() const {
        return reducedCostMultiplier_;
    }

protected:
    // Data
    double startTime_;
    double maximumTime_;
    double fakeCutoff_;
    double absoluteIncrement_;
    double relativeIncrement_;
    double defaultRounding_;
    double initialWeight_;
    double weightFactor_;
    double artificialCost_;
    double iterationRatio_;
    double reducedCostMultiplier_;
    int maximumPasses_;
    int maximumRetries_;
    int accumulate_;
    int fixOnReducedCosts_;
    bool roundExpensive_;

private:
    int rounds(OsiSolverInterface * solver, double * solution,
               /*const double * objective, */
               int numberIntegers, const int * integerVariable,
               /*char * pumpPrint,*/int passNumber,
               /*bool roundExpensive=false,*/
               double downValue = 0.5, int *flip = 0);
    /* note for eagle eyed readers.
       when_ can now be exotic -
       <=10 normal
    */
};

# ifdef COIN_HAS_CLP

class CbcDisasterHandler : public OsiClpDisasterHandler {
public:
#ifdef JJF_ZERO
    virtual void intoSimplex();
    virtual bool check() const ;
    virtual void saveInfo();
#endif
    virtual int typeOfDisaster();


    CbcDisasterHandler(CbcModel * model = NULL);
    virtual ~CbcDisasterHandler();
    // Copy
    CbcDisasterHandler(const CbcDisasterHandler&);
    // Assignment
    CbcDisasterHandler& operator=(const CbcDisasterHandler&);
    virtual ClpDisasterHandler * clone() const;


    void setCbcModel(CbcModel * model);
    inline CbcModel * cbcModel() const {
        return cbcModel_;
    }



protected:
    CbcModel * cbcModel_;

};
#endif

#endif