CbcHeuristicDive.hpp

Go to the documentation of this file.

/* $Id: CbcHeuristicDive.hpp 2467 2019-01-03 21:26:29Z unxusr $ */
// 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
*/