CbcHeuristicGreedy.hpp

Go to the documentation of this file.

/* $Id: CbcHeuristicGreedy.hpp 1585 2011-01-11 19:04:34Z forrest $ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcHeuristicGreedy_H
#define CbcHeuristicGreedy_H
 
#include "CbcHeuristic.hpp"
class CbcHeuristicGreedyCover : public CbcHeuristic {
public:
 
    // Default Constructor
    CbcHeuristicGreedyCover ();
 
    /* Constructor with model - assumed before cuts
       Initial version does not do Lps
    */
    CbcHeuristicGreedyCover (CbcModel & model);
 
    // Copy constructor
    CbcHeuristicGreedyCover ( const CbcHeuristicGreedyCover &);
 
    // Destructor
    ~CbcHeuristicGreedyCover ();
 
    virtual CbcHeuristic * clone() const;
    CbcHeuristicGreedyCover & operator=(const CbcHeuristicGreedyCover& rhs);
    virtual void generateCpp( FILE * fp) ;
 
    virtual void setModel(CbcModel * model);
 
    using CbcHeuristic::solution ;
    virtual int solution(double & objectiveValue,
                         double * newSolution);
    virtual void validate() ;
    virtual void resetModel(CbcModel * model);
    /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
       if 100 added round up all >=0.5
    */
    inline int algorithm() const {
        return algorithm_;
    }
    inline void setAlgorithm(int value) {
        algorithm_ = value;
    }
    // Only do this many times
    inline int numberTimes() const {
        return numberTimes_;
    }
    inline void setNumberTimes(int value) {
        numberTimes_ = value;
    }
 
protected:
    void gutsOfConstructor(CbcModel * model);
    // Data
 
    // Original matrix by column
    CoinPackedMatrix matrix_;
    // original number of rows
    int originalNumberRows_;
    /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
    */
    int algorithm_;
    int numberTimes_;
 
};
 
 
class CbcHeuristicGreedyEquality : public CbcHeuristic {
public:
 
    // Default Constructor
    CbcHeuristicGreedyEquality ();
 
    /* Constructor with model - assumed before cuts
       Initial version does not do Lps
    */
    CbcHeuristicGreedyEquality (CbcModel & model);
 
    // Copy constructor
    CbcHeuristicGreedyEquality ( const CbcHeuristicGreedyEquality &);
 
    // Destructor
    ~CbcHeuristicGreedyEquality ();
 
    virtual CbcHeuristic * clone() const;
    CbcHeuristicGreedyEquality & operator=(const CbcHeuristicGreedyEquality& rhs);
    virtual void generateCpp( FILE * fp) ;
 
    virtual void setModel(CbcModel * model);
 
    using CbcHeuristic::solution ;
    virtual int solution(double & objectiveValue,
                         double * newSolution);
    virtual void validate() ;
    virtual void resetModel(CbcModel * model);
    /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
       if 100 added round up all >=0.5
    */
    inline int algorithm() const {
        return algorithm_;
    }
    inline void setAlgorithm(int value) {
        algorithm_ = value;
    }
    // Fraction of rhs to cover before branch and cut
    inline void setFraction(double value) {
        fraction_ = value;
    }
    inline double fraction() const {
        return fraction_;
    }
    // Only do this many times
    inline int numberTimes() const {
        return numberTimes_;
    }
    inline void setNumberTimes(int value) {
        numberTimes_ = value;
    }
protected:
    void gutsOfConstructor(CbcModel * model);
    // Data
 
    // Original matrix by column
    CoinPackedMatrix matrix_;
    // Fraction of rhs to cover before branch and cut
    double fraction_;
    // original number of rows
    int originalNumberRows_;
    /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
    */
    int algorithm_;
    int numberTimes_;
 
};
 
class CbcHeuristicGreedySOS : public CbcHeuristic {
public:
 
    // Default Constructor
    CbcHeuristicGreedySOS ();
 
    /* Constructor with model - assumed before cuts
       Initial version does not do Lps
    */
    CbcHeuristicGreedySOS (CbcModel & model);
 
    // Copy constructor
    CbcHeuristicGreedySOS ( const CbcHeuristicGreedySOS &);
 
    // Destructor
    ~CbcHeuristicGreedySOS ();
 
    virtual CbcHeuristic * clone() const;
    CbcHeuristicGreedySOS & operator=(const CbcHeuristicGreedySOS& rhs);
    virtual void generateCpp( FILE * fp) ;
 
    virtual void setModel(CbcModel * model);
 
    using CbcHeuristic::solution ;
    virtual int solution(double & objectiveValue,
                         double * newSolution);
    virtual void validate() ;
    virtual void resetModel(CbcModel * model);
    /* Algorithm
       Bits
       1 bit - use current model, otherwise original
       2 - use current solution as starting point, otherwise pure greedy
       4 - as 2 but use merit not merit/size
       8 - use duals to modify greedy
       16 - use duals on GUB/SOS in special way
    */
    inline int algorithm() const {
        return algorithm_;
    }
    inline void setAlgorithm(int value) {
        algorithm_ = value;
    }
    // Only do this many times
    inline int numberTimes() const {
        return numberTimes_;
    }
    inline void setNumberTimes(int value) {
        numberTimes_ = value;
    }
 
protected:
    void gutsOfConstructor(CbcModel * model);
    // Data
 
    // Original RHS - if -1.0 then SOS otherwise <= value
    double * originalRhs_;
    // Original matrix by column
    CoinPackedMatrix matrix_;
    // original number of rows
    int originalNumberRows_;
    /* Algorithm
    */
    int algorithm_;
    int numberTimes_;
 
};
 
 
#endif