CbcHeuristicDive.hpp

Go to the documentation of this file.

/* $Id: CbcHeuristicDive.hpp 1252 2009-10-20 09:22:24Z stefan $ */
// Copyright (C) 2008, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcHeuristicDive_H
#define CbcHeuristicDive_H

#include "CbcHeuristic.hpp"
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);

    virtual void validate();

    void selectBinaryVariables();

    void setPercentageToFix(double value) {
        percentageToFix_ = value;
    }

    void setMaxIterations(int value) {
        maxIterations_ = value;
    }

    void setMaxSimplexIterations(int value) {
        maxSimplexIterations_ = value;
    }

    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_;

    // 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 number of major iterations
    int maxIterations_;

    // Maximum number of simplex iterations
    int maxSimplexIterations_;

    // Maximum number of simplex iterations at root node
    int maxSimplexIterationsAtRoot_;

    // Maximum time allowed
    double maxTime_;

};
#endif