CouenneIterativeRounding.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation 2007 
// All Rights Reserved.
// This code is published under the Eclipse Public License (EPL).
//
// Authors :
// Giacomo Nannicini, Tepper School of Business, Carnegie Mellon University
//
// Date : 07/25/2010

#ifndef COUENNEITERATIVEROUNDING_HPP
#define COUENNEITERATIVEROUNDING_HPP

#include "CouenneConfig.h"
#include "CbcHeuristic.hpp"
#include "BonOsiTMINLPInterface.hpp"

#ifdef COIN_HAS_CPX
#include "OsiCpxSolverInterface.hpp"
#else
#include "CbcHeuristicFPump.hpp"
#include "CbcHeuristicRINS.hpp"
#include "CbcHeuristicDiveFractional.hpp"
#include "CbcHeuristicRandRound.hpp"
#endif

#include "CouenneCutGenerator.hpp"
#include "CouenneProblem.hpp"

namespace Couenne{

  class CouenneIterativeRounding : public CbcHeuristic{

  public:
    CouenneIterativeRounding();
    CouenneIterativeRounding(Bonmin::OsiTMINLPInterface* nlp, 
                             OsiSolverInterface* cinlp,
                             CouenneProblem* couenne,
                             Ipopt::SmartPtr<Ipopt::OptionsList> options);
    CouenneIterativeRounding(const CouenneIterativeRounding &other);
    
    virtual ~CouenneIterativeRounding();
    
    virtual CbcHeuristic * clone() const;
    
    CouenneIterativeRounding & operator=(const CouenneIterativeRounding &rhs);
    
    void setNlp (Bonmin::OsiTMINLPInterface* nlp, OsiSolverInterface* cinlp);

    void setCouenneProblem(CouenneProblem* couenne){
      couenne_ = couenne;
    }

    void resetModel(CbcModel * model){}
    int solution(double & objectiveValue, double * newSolution);

    void setMaxRoundingIter(int value){
      maxRoundingIter_ = value;
    }
    
    void setMaxFirPoints(int value){
      maxFirPoints_ = value;
    }

    void setMaxTime(double value){
      maxTime_ = value;
    }

    void setMaxTimeFirstCall(double value){
      maxTimeFirstCall_ = value;
    }

    void setOmega(double value){
      omega_ = value;
    }

    void setBaseLbRhs(int value){
      baseLbRhs_ = value;
    }

    void setAggressiveness(int value);

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

private:
    Bonmin::OsiTMINLPInterface * nlp_;
    OsiSolverInterface * cinlp_;
#ifdef COIN_HAS_CPX
    OsiCpxSolverInterface * milp_;
#else
    OsiClpSolverInterface * milp_;
#endif

    int maxRoundingIter_;
    int maxFirPoints_;
    double maxTime_;
    double maxTimeFirstCall_;
    int numInitialRows_;
    int numSol_;
    int numIntegers_;
    double* colLower_;
    double* colUpper_;
    double* colLowerNlp_;
    double* colUpperNlp_;
#ifndef COIN_HAS_CPX

    CbcHeuristic** heuristics_;
    int numHeuristics_;
#endif

    double startTime_;
    double endTime_;
    double omega_;
    int baseLbRhs_;

    CouenneProblem * couenne_;

    inline bool areEqual(double a, double b){
      return (fabs(a-b) <= COUENNE_EPS);
    }

    /* Try to find a first feasible solution */
    int feasibilityIR(double& objectiveValue, double* newSolution);

    /* Try to improve a given solution */
    int improvementIR(double& objectiveValue, double* newSolution,
                      const double* startingSolution);

    void setMilp();

    int computeIntAtBound(const double* x);

    int computeIntAtBound(const double* x, double& avgBoundSize);

    void writeLB(OsiRowCut& cut, const double* x, char sense, double rhs);

    int branchToCut(const double* x, OsiSolverInterface* solver,
                    std::vector<int>& previousBranches);

    bool solveMilp(OsiSolverInterface* milp, double maxTime);
  };
}/* Ends namespace Couenne. */

#endif