CbcHeuristicDive.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2008, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcHeuristicDive_H
#define CbcHeuristicDive_H
 
#include "CbcHeuristic.hpp"
class CbcSubProblem;
class OsiRowCut;
struct PseudoReducedCost {
  int var;
  double pseudoRedCost;
};
 
class CbcHeuristicDive : public CbcHeuristic {
public:
  // Default Constructor
  CbcHeuristicDive();
 
  // Constructor with model - assumed before cuts
  CbcHeuristicDive(CbcModel &model);
 
  // Copy constructor
  CbcHeuristicDive(const CbcHeuristicDive &);
 
  // Destructor
  ~CbcHeuristicDive();
 
  virtual CbcHeuristicDive *clone() const = 0;
 
  CbcHeuristicDive &operator=(const CbcHeuristicDive &rhs);
 
  virtual void generateCpp(FILE *) {}
 
  void generateCpp(FILE *fp, const char *heuristic);
 
  virtual void resetModel(CbcModel *model);
 
  virtual void setModel(CbcModel *model);
 
  //  REMLOVE using CbcHeuristic::solution ;
  virtual int solution(double &objectiveValue,
    double *newSolution);
  int solution(double &objectiveValue, int &numberNodes,
    int &numberCuts, OsiRowCut **cuts,
    CbcSubProblem **&nodes,
    double *newSolution);
  int fathom(CbcModel *model, int &numberNodes, CbcSubProblem **&nodes);
 
  virtual void validate();
 
  void setPriorities();
 
  void selectBinaryVariables();
 
  void setPercentageToFix(double value)
  {
    percentageToFix_ = value;
  }
 
  void setMaxIterations(int value)
  {
    maxIterations_ = value;
  }
 
  void setMaxSimplexIterations(int value)
  {
    maxSimplexIterations_ = value;
  }
  inline int maxSimplexIterations() const
  {
    return maxSimplexIterations_;
  }
 
  void setMaxSimplexIterationsAtRoot(int value)
  {
    maxSimplexIterationsAtRoot_ = value;
  }
 
  void setMaxTime(double value)
  {
    maxTime_ = value;
  }
 
  virtual bool canHeuristicRun();
 
  virtual bool selectVariableToBranch(OsiSolverInterface *solver,
    const double *newSolution,
    int &bestColumn,
    int &bestRound)
    = 0;
  virtual void initializeData() {}
 
  int reducedCostFix(OsiSolverInterface *solver);
  virtual int fixOtherVariables(OsiSolverInterface *solver,
    const double *solution,
    PseudoReducedCost *candidate,
    const double *random);
 
protected:
  // Data
 
  // Original matrix by column
  CoinPackedMatrix matrix_;
 
  // Original matrix by
  CoinPackedMatrix matrixByRow_;
 
  // Down locks
  unsigned short *downLocks_;
 
  // Up locks
  unsigned short *upLocks_;
 
  double *downArray_;
 
  double *upArray_;
 
  typedef struct {
    unsigned int direction : 3; //  0 bit off, 1 bit (0 down first, 1 up first) 2 bit non zero don't try other way
    unsigned int priority : 29;
  } PriorityType;
  PriorityType *priority_;
  // Indexes of binary variables with 0 objective coefficient
  // and in variable bound constraints
  std::vector< int > binVarIndex_;
 
  // Indexes of variable bound rows for each binary variable
  std::vector< int > vbRowIndex_;
 
  // Percentage of integer variables to fix at bounds
  double percentageToFix_;
 
  // Maximum time allowed
  double maxTime_;
 
  // Small objective (i.e. treat zero objective as this)
  double smallObjective_;
 
  // Maximum number of major iterations
  int maxIterations_;
 
  // Maximum number of simplex iterations
  int maxSimplexIterations_;
 
  // Maximum number of simplex iterations at root node
  int maxSimplexIterationsAtRoot_;
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/