BonBqpdSolver.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.
//
// Authors :
// Andreas Waechter, International Business Machines Corporation
//                    based on BonFilterSolver.cpp
//
// Date : 07/09/2007

#ifndef BonBqpdSolver_H
#define BonBqpdSolver_H

#include "BonTNLPSolver.hpp"
#include "BonBranchingTQP.hpp"

//#define TIME_BQPD
namespace Bonmin
{
  class BqpdSolver : public TNLPSolver
  {
  public:
    friend class FilterSolver;


  class UnsolvedBqpdError: public TNLPSolver::UnsolvedError
    {
    public:
      UnsolvedBqpdError(int errorNum,
          Ipopt::SmartPtr<TMINLP2TNLP> model,
          const std::string &name):
          TNLPSolver::UnsolvedError(errorNum, model, name)
      {}
      virtual const std::string& errorName() const;

      virtual const std::string& solverName() const;
      virtual ~UnsolvedBqpdError()
      {}

    private:
      static std::string errorNames_[1];
      static std::string solverName_;
    };

    typedef ipfint fint;
    typedef double real;

    virtual UnsolvedError*
    newUnsolvedError(int num,
        Ipopt::SmartPtr<TMINLP2TNLP> problem,
        std::string name)
    {
      return new UnsolvedBqpdError(num, problem, name);
    }

    BqpdSolver(bool createEmpty = false);

    BqpdSolver(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
        Ipopt::SmartPtr<Ipopt::OptionsList> options,
        Ipopt::SmartPtr<Ipopt::Journalist> journalist,
        const std::string & prefix
              );

    virtual ~BqpdSolver();

    virtual bool Initialize(std::string params_file);

    virtual bool Initialize(std::istream& is);

    virtual ReturnStatus OptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp);

    virtual ReturnStatus ReOptimizeTNLP(const Ipopt::SmartPtr<Ipopt::TNLP> & tnlp);

    virtual bool setWarmStart(const CoinWarmStart * warm,
        Ipopt::SmartPtr<TMINLP2TNLP> tnlp);

    virtual bool markHotStart(){return cached_->markHotStart();}

    virtual CoinWarmStart * getUsedWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const{
      throw CoinError(__PRETTY_FUNCTION__,"","Not implemented");
    }

    virtual CoinWarmStart * getWarmStart(Ipopt::SmartPtr<TMINLP2TNLP> tnlp) const;

    virtual CoinWarmStart * getEmptyWarmStart() const;

    virtual bool warmStartIsValid(const CoinWarmStart * ws) const;

    virtual void enableWarmStart()
    {//No options to be set
    }
    virtual void disableWarmStart()
    {//No options to be set
    }

    virtual Ipopt::SmartPtr<TNLPSolver> clone();

    virtual double CPUTime()
    {
      return (Ipopt::IsValid(cached_)) ? cached_->cpuTime_: 0.;
    }

    virtual int IterationCount()
    {
      return 0;
    }


    // turn off all output from the solver
    virtual void setOutputToDefault()
    {
      if (Ipopt::IsValid(cached_)) cached_->iprint = default_log_level_;
    }
    virtual void forceSolverOutput(int log_level)
    {
      if (Ipopt::IsValid(cached_)) cached_->iprint = log_level;
    }
    
    virtual std::string & solverName()
    {
      return solverName_;
    }

    void registerOptions()
    {
      registerOptions(roptions_);
    }

    virtual int errorCode() const
    {
      return -1;
    }
#ifdef TIME_BQPD
  struct Times {
    int numsolve;
    double create;
    double solve;
    double resolve;
    double warm_start;
    int pivots;
    Times(): numsolve(0), create(0), solve(0), resolve(0), warm_start(0), pivots(0){
    }

    Times & operator +=(Times &rhs){
      numsolve += rhs.numsolve;
      create += rhs.create;
      solve += rhs.solve;
      resolve += rhs.resolve;
      warm_start += rhs.warm_start;
      pivots += rhs.pivots;
      return *this;
    }
  };
#endif

    static void registerOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
  private:
    TNLPSolver::ReturnStatus callOptimizer();
    double fillin_factor_;
    int kmax_ipt_;
    int mlp_ipt_;
    static int m0de_;
    static int reinit_freq_;

  struct cachedInfo : public Ipopt::ReferencedObject
    {
#ifdef TIME_BQPD
  Times times_;
#endif

      fint n;
      fint m;
      fint k;
      fint kmax;
      real* a;
      fint* la;
      real* x;
      real* bl;
      real* bu;
      real f;
      real* g;
      real* r;
      real* w;
      real* e;
      fint* ls;
      real* alp;
      fint* lp;
      fint mlp;
      fint peq;
      real* ws;
      fint* lws;
      fint m0de;
      fint ifail;
      fint info[1];
      fint iprint;
      fint nout;

      fint kk,ll,mxws,mxlws;

      bool haveHotStart_;
      fint irh1,na,na1,nb,nb1,ka1,kb1,kc1,irg1,lu1,lv,lv1,ll1;
      real eps,tol,emin;
      real vstep;
      real sgnf;
      fint nrep,npiv,nres;
      fint nup,nfreq;
      real alpha;
      fint ns,ns1,nt,nt1,nu,nu1,nx,nx1,np,np1,nprof,lc;
      fint lc1,li,li1,lm,lm1,lp_,lp1,lq,lq1,lr,lr1,ls_,ls1,lt,lt1;
      fint m1,m2,mp,mq,lastr,irow;
      fint mxm1;
      real c;
      fint kHot;
      real* xHot;
      real fHot;
      real* gHot;
      real* rHot;
      real* wHot;
      real* eHot;
      fint* lsHot;
      real* alpHot;
      fint* lpHot;
      fint peqHot;
      real* wsHot;
      fint* lwsHot;
      fint infoHot[1];
      fint kkkHot;
      fint lllHot;
      fint kkHot;
      fint llHot;

      Ipopt::SmartPtr<BranchingTQP> tqp_;
      double cpuTime_;
      bool use_warm_start_in_cache_;
      bool bad_warm_start_info_;

      int amax_;

      double* fillin_factor_;

      int next_reinit_;
      int pivots_;
      cachedInfo()
          :
          a(NULL),
          la(NULL),
          x(NULL),
          bl(NULL),
          bu(NULL),
          g(NULL),
          r(NULL),
          w(NULL),
          e(NULL),
          ls(NULL),
          alp(NULL),
          lp(NULL),
          ws(NULL),
          lws(NULL),
          haveHotStart_(false),
          xHot(NULL),
          gHot(NULL),
          rHot(NULL),
          wHot(NULL),
          eHot(NULL),
          lsHot(NULL),
          alpHot(NULL),
          lpHot(NULL),
          wsHot(NULL),
          lwsHot(NULL),
          cpuTime_(0),
          use_warm_start_in_cache_(false),
          bad_warm_start_info_(false),
          next_reinit_(0),
          pivots_(0)
      {}

      cachedInfo(const Ipopt::SmartPtr<BranchingTQP> &tqp,
                 Ipopt::SmartPtr<Ipopt::OptionsList>& options,
                 int kmax_ipt, int mlp_ipt, double* fillin_factor):
          a(NULL),
          la(NULL),
          x(NULL),
          bl(NULL),
          bu(NULL),
          g(NULL),
          r(NULL),
          w(NULL),
          e(NULL),
          ls(NULL),
          alp(NULL),
          lp(NULL),
          ws(NULL),
          lws(NULL),
          haveHotStart_(false),
          xHot(NULL),
          gHot(NULL),
          rHot(NULL),
          wHot(NULL),
          eHot(NULL),
          lsHot(NULL),
          alpHot(NULL),
          lpHot(NULL),
          wsHot(NULL),
          lwsHot(NULL),
          tqp_(tqp),
          cpuTime_(0),
          use_warm_start_in_cache_(false),
          bad_warm_start_info_(false),
          next_reinit_(0),
          pivots_(0)
      {
        initialize(tqp, options, kmax_ipt, mlp_ipt, fillin_factor);
      }

      void initialize(const Ipopt::SmartPtr<BranchingTQP> &tqp,
                      Ipopt::SmartPtr<Ipopt::OptionsList>& options,
                      int kmax_ipt, int mlp_ipt, double* fillin_factor);

      void re_initialize();
      void optimize();

      bool markHotStart();

      void unmarkHotStart();

      void copyFromHotStart();

      ~cachedInfo();
    };

    Ipopt::SmartPtr<cachedInfo> cached_;

    static std::string  solverName_;

     int default_log_level_;

    public:

#ifdef TIME_BQPD
    Times &times(){ return cached_->times_;}
#endif

  };

}// end namespace Bonmin
#endif