CbcHeuristicDive.hpp

Go to the documentation of this file.

/* $Id: CbcHeuristicDive.hpp 2093 2014-11-06 16:17:38Z forrest $ */
// 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