CbcHeuristicDW.hpp

Go to the documentation of this file.

// $Id: CbcHeuristicDW.hpp 1899 2013-04-09 18:12:08Z stefan $
// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcHeuristicDW_H
#define CbcHeuristicDW_H
 
#include "CbcHeuristic.hpp"
 
class CbcHeuristicDW : public CbcHeuristic {
public:
  // Default Constructor
  CbcHeuristicDW();
 
  /* Constructor with model - assumed before cuts
    */
  CbcHeuristicDW(CbcModel &model, int keepContinuous = 0);
 
  /* Constructor with model - assumed before cuts
    */
  CbcHeuristicDW(CbcModel &model,
    int callBack(CbcHeuristicDW *currentHeuristic,
      CbcModel *thisModel,
      int whereFrom),
    int keepContinuous = 0);
 
  // Copy constructor
  CbcHeuristicDW(const CbcHeuristicDW &);
 
  // Destructor
  ~CbcHeuristicDW();
 
  virtual CbcHeuristic *clone() const;
 
  CbcHeuristicDW &operator=(const CbcHeuristicDW &rhs);
 
  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);
  inline int numberBlocks() const
  {
    return numberBlocks_;
  }
  void passInSolution(const double *solution);
  void passInContinuousSolution(const double *solution);
  void setProposalActions(int fullDWEverySoOften);
  double objectiveValueWhen(int whichDW) const;
  int numberColumnsDW(int whichDW) const;
  inline OsiSolverInterface *solver() const
  {
    return solver_;
  }
  OsiSolverInterface *DWModel(int whichDW) const;
  inline double bestObjective() const
  {
    return bestObjective_;
  }
  inline const double *bestSolution() const
  {
    return bestSolution_;
  }
  inline const double *continuousSolution() const
  {
    return continuousSolution_;
  }
  inline const double *fixedDj() const
  {
    return fixedDj_;
  }
  inline const double *objectiveDW() const
  {
    return objectiveDW_;
  }
  inline int numberDWTimes() const
  {
    return numberDWTimes_;
  }
  inline const int *numberColumnsDW() const
  {
    return numberColumnsDW_;
  }
  inline void setNumberPasses(int value)
  {
    numberPasses_ = value;
  }
  inline void setNumberBadPasses(int value)
  {
    numberBadPasses_ = value;
  }
  inline void setNumberNeeded(int value)
  {
    nNeededBase_ = value;
  }
  inline int getNumberNeeded() const
  {
    return nNeededBase_;
  }
  inline void setCurrentNumberNeeded(int value)
  {
    nNeeded_ = value;
  }
  inline int getCurrentNumberNeeded() const
  {
    return nNeeded_;
  }
  inline void setNumberNodes(int value)
  {
    nNodesBase_ = value;
  }
  inline int getNumberNodes() const
  {
    return nNodesBase_;
  }
  inline void setCurrentNumberNodes(int value)
  {
    nNodes_ = value;
  }
  inline int getCurrentNumberNodes() const
  {
    return nNodes_;
  }
  inline void setTargetObjective(double value)
  {
    targetObjective_ = value;
  }
  inline void setHowOften(int value)
  {
    howOften_ = value;
  }
  inline const int *whichRowBlock() const
  {
    return whichRowBlock_;
  }
  inline const int *whichColumnBlock() const
  {
    return whichColumnBlock_;
  }
  inline double *initialLower() const
  {
    return saveLower_;
  }
  inline double *initialUpper() const
  {
    return saveUpper_;
  }
  inline int *intArrays() const
  {
    return intArray_;
  }
  inline double *doubleArrays() const
  {
    return doubleArray_;
  }
  inline int phase() const
  {
    return phase_;
  }
  inline int pass() const
  {
    return pass_;
  }
  inline const int *columnsInBlock() const
  {
    return columnsInBlock_;
  }
  inline const int *startColumnBlock() const
  {
    return startColumnBlock_;
  }
  inline const int *intsInBlock() const
  {
    return intsInBlock_;
  }
  double objectiveValue(const double *solution);
 
private:
  void gutsOfCopy(const CbcHeuristicDW &rhs);
  void gutsOfDelete();
  void setDefaults();
  void findStructure();
  void setupDWStructures();
  int addDW(const double *solution, int numberBlocksUsed,
    const int *whichBlocks);
 
protected:
  typedef int (*heuristicCallBack)(CbcHeuristicDW *, CbcModel *, int);
  // Data
  double targetObjective_;
  double bestObjective_;
  double lastObjective_;
  heuristicCallBack functionPointer_;
  int *intArray_;
  double *doubleArray_;
  OsiSolverInterface *solver_;
  OsiSolverInterface *dwSolver_;
  double *bestSolution_;
  double *continuousSolution_;
  double *fixedDj_;
  double *saveLower_;
  double *saveUpper_;
  double *random_;
  double *weights_;
  double *objectiveDW_;
  int *numberColumnsDW_;
  int *whichRowBlock_;
  int *whichColumnBlock_;
  int *dwBlock_;
  int *backwardRow_;
  int *rowsInBlock_;
  int *columnsInBlock_;
  int *startRowBlock_;
  int *startColumnBlock_;
  int *intsInBlock_;
  unsigned int *fingerPrint_;
  unsigned short *affinity_;
  int fullDWEverySoOften_;
  int numberPasses_;
  int howOften_;
  int maximumDW_;
  int numberDW_;
  int numberDWTimes_;
  int sizeFingerPrint_;
  int numberMasterColumns_;
  int numberMasterRows_;
  int numberBlocks_;
  int keepContinuous_;
  int phase_;
  int pass_;
  int nNeededBase_;
  int nNodesBase_;
  int nNeeded_;
  int nNodes_;
  int numberBadPasses_;
  // 0 - fine, 1 can't be better, 2 max node
  int solveState_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/