CbcHeuristicFPump.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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);
  int solutionGeneral(double &objectiveValue, double *newSolution,
    int maxAround = 1, bool fixSatisfied = false);
  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);
  int solutionInternal(double &objectiveValue, double *newSolution);
  /* 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/