c/coinor-cbc/coinor-libcbc-doc_2.9.9%2Brepack1-1_all.deb

// $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