/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcHeuristicFPump.hpp

Go to the documentation of this file.

// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcHeuristicFeasibilityPump_H
#define CbcHeuristicFeasibilityPump_H

#include "CbcHeuristic.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 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_;}

protected:
  // Data
  double startTime_;
  double maximumTime_;
  double fakeCutoff_;
  double absoluteIncrement_;
  double relativeIncrement_;
  double defaultRounding_;
  double initialWeight_;
  double weightFactor_;
  double artificialCost_;
  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
  */
};


#endif

---