CouenneFeasPump.hpp

Go to the documentation of this file.

/* $Id: CouenneFeasPump.hpp 1071 2014-03-13 01:35:13Z pbelotti $
 *
 * Name:    CouenneFeasPump.hpp
 * Authors: Pietro Belotti
 *          Timo Berthold, ZIB Berlin
 * Purpose: Define the Feasibility Pump heuristic class
 * Created: August 5, 2009
 *
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef CouenneFeasPump_HPP
#define CouenneFeasPump_HPP

#include <queue>

#include "CouenneTypes.hpp"
#include "CbcHeuristic.hpp"
#include "CouenneFPpool.hpp"
#include "IpOptionsList.hpp"

#ifdef COIN_HAS_SCIP
#include "scip/scip.h"
#endif

struct Scip;
class OsiSolverInterface;

//
// A fading coefficient decreases from a to a^k at every iteration if
// a > 0. If a is negative, then it increases from 1-|a| = 1+a to
// 1-|a|^k and eventually converges to 1
//

inline double fadingCoeff (double a)
{return (a<0) ? a+1 : a;}

namespace Ipopt {
  class IpoptApplication;
}

namespace Bonmin {
  class RegisteredOptions;
}

namespace Couenne {

  class expression;
  class CouenneProblem;
  class CouenneCutGenerator;
  class CouenneTNLP;
  class CouenneSparseMatrix;

  
  class CouenneFeasPump: public CbcHeuristic {

  public:

    enum fpCompDistIntType {FP_DIST_INT,  FP_DIST_ALL,       FP_DIST_POST};
    enum fpCutPlane        {FP_CUT_NONE,  FP_CUT_INTEGRATED, FP_CUT_EXTERNAL, FP_CUT_POST}; 
    enum fpTabuMgtPolicy   {FP_TABU_NONE, FP_TABU_POOL,      FP_TABU_PERTURB, FP_TABU_CUT};

    CouenneFeasPump (CouenneProblem *couenne                     = NULL,
                     CouenneCutGenerator *cg                     = NULL,
                     Ipopt::SmartPtr<Ipopt::OptionsList> options = NULL);

    CouenneFeasPump (const CouenneFeasPump &other);
    
    virtual ~CouenneFeasPump();

    virtual CbcHeuristic *clone () const;
    
    CouenneFeasPump &operator= (const CouenneFeasPump &rhs);

    virtual void resetModel (CbcModel *model) {}

    virtual int solution (double &objectiveValue, double *newSolution);

    void setNumberSolvePerLevel (int value)
    {numberSolvePerLevel_ = value;}

#ifdef COIN_HAS_SCIP
    void checkInfinity (struct Scip *scip, double val, double infinity);
#endif

    virtual CouNumber solveMILP (const CouNumber *nSol, CouNumber *&iSol, int niter, int* nsuciter); 

    virtual CouNumber solveNLP  (const CouNumber *nSol, CouNumber *&iSol);

    expression *updateNLPObj (const double *);

    bool fixIntVariables (const double *sol);

    static void registerOptions (Ipopt::SmartPtr <Bonmin::RegisteredOptions>);

    double findSolution (const double *nSol, double *&sol, int niter, int* nsuciter);

    void init_MILP ();

    void initIpoptApp ();

    CouenneProblem *Problem () const
    {return problem_;}

    enum fpCompDistIntType compDistInt () const
    {return compDistInt_;}


    double multDistNLP  () const {return fadingCoeff (multDistNLP_);}  
    double multHessNLP  () const {return fadingCoeff (multHessNLP_);}  
    double multObjFNLP  () const {return fadingCoeff (multObjFNLP_);}  

    double multDistMILP () const {return fadingCoeff (multDistMILP_);} 
    double multHessMILP () const {return fadingCoeff (multHessMILP_);} 
    double multObjFMILP () const {return fadingCoeff (multObjFMILP_);} 

    CouenneTNLP *nlp () const
    {return nlp_;}

    int &nCalls ()
    {return nCalls_;}

    int milpPhase (double *nSol, double *iSol);

    int nlpPhase (double *iSol, double *nSol);

#ifdef COIN_HAS_SCIP
    SCIP_RETCODE ScipSolve (const double *nSol, double* &sol, int niter, int* nsuciter, CouNumber &obj);
#endif

  private:

    //
    // ESSENTIAL TOOLS for the FP: a problem pointer and one for the
    // linearization cut generator
    //

    CouenneProblem *problem_;

    CouenneCutGenerator *couenneCG_;

    //
    // PERSISTENT OBJECTS
    //
    // (not necessary to identify FP, but useful to keep between
    // calls)
    //

    CouenneTNLP *nlp_;

    Ipopt::IpoptApplication *app_;

    OsiSolverInterface *milp_;

    OsiSolverInterface *postlp_;

    CouenneFPpool *pool_;

    std::set <CouenneFPsolution, compareSol> tabuPool_;

    int *match_;

    //
    // PARAMETERS
    //

    int numberSolvePerLevel_;


    double multDistNLP_;  
    double multHessNLP_;  
    double multObjFNLP_;  

    double multDistMILP_; 
    double multHessMILP_; 
    double multObjFMILP_; 

    enum fpCompDistIntType compDistInt_;

    enum fpCutPlane milpCuttingPlane_;

    int nSepRounds_;

    int maxIter_;

    bool useSCIP_;

    int milpMethod_;

    enum fpTabuMgtPolicy tabuMgt_;

    int nCalls_;

    double fadeMult_;
  };
}

#endif