BundleTerminator.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_BUNDLETERMINATOR_HXX
#define CONICBUNDLE_BUNDLETERMINATOR_HXX


#include "matrix.hxx"
#include "clock.hxx"
#include "CBSolver.hxx"
#include "CBout.hxx"

namespace ConicBundle {


class BundleTerminatorData
{
public:
  virtual ~BundleTerminatorData(); //implemented in BundleTerminator.cxx

  virtual CH_Matrix_Classes::Integer get_cntobjeval() const =0;
  virtual CH_Matrix_Classes::Integer get_sumrecomp() const =0;
  virtual CH_Matrix_Classes::Integer get_suminnerit() const =0;
  virtual CH_Matrix_Classes::Integer get_sumqpfails() const =0;
  virtual CH_Matrix_Classes::Real get_center_objval() const =0;
  virtual CH_Matrix_Classes::Real get_cand_objval() const =0;
  virtual CH_Matrix_Classes::Real get_modelval() const =0;
  virtual CH_Matrix_Classes::Real get_aggr_dnormsqr() const =0;
 virtual CH_Matrix_Classes::Integer get_summodelfails() const =0;
  virtual CH_Matrix_Classes::Integer get_augvalfails() const =0;
  virtual CH_Matrix_Classes::Integer get_sumaugvalfails() const =0;
  virtual CH_Matrix_Classes::Integer get_oraclefails() const =0;
  virtual CH_Matrix_Classes::Integer get_sumoraclefails() const =0;
  virtual CH_Matrix_Classes::Real get_term_corr() const =0;

};


class BundleSolver;
class NBundleSolver;

  class BundleTerminator: public CBout
{
  friend class BundleSolver;
  friend class NBundleSolver;

protected:
  CH_Matrix_Classes::Real termeps;
  CH_Matrix_Classes::Real aggregate_dnormsqr;         

  const CH_Tools::Clock* clockp;
  CH_Tools::Microseconds timelimit;  

  CH_Matrix_Classes::Integer recomplimit;     

  CH_Matrix_Classes::Integer qpfailslimit;     

  CH_Matrix_Classes::Integer modelfailslimit;
  
  CH_Matrix_Classes::Integer augvalfailslimit;
  
  CH_Matrix_Classes::Integer objevallimit;     

  CH_Matrix_Classes::Integer oraclefailslimit; 

  int terminated;  


  virtual int check_termination(BundleTerminatorData* sb)
  {
    terminated=0;
    if (clockp)
      terminated|=2*(clockp->time()>=timelimit);
    if (recomplimit>=0)
      terminated|=4*(recomplimit<=sb->get_sumrecomp()); 
    if (qpfailslimit>=0)
      terminated|=8*(qpfailslimit<=sb->get_sumqpfails());
    if (modelfailslimit>=0)
      terminated|=16*(modelfailslimit<=sb->get_summodelfails());
    if (augvalfailslimit>=0)
      terminated|=32*(augvalfailslimit<=sb->get_sumaugvalfails());
    if (objevallimit>=0)
      terminated|=64*(objevallimit<=sb->get_cntobjeval());
    if (oraclefailslimit>=0)
      terminated|=128*(oraclefailslimit<=sb->get_sumoraclefails());
    if ((sb->get_suminnerit()<10)&&(sb->get_aggr_dnormsqr()>0.1)) return terminated;
    if ((aggregate_dnormsqr>0)&&(sb->get_aggr_dnormsqr()>aggregate_dnormsqr)) return terminated;
    CH_Matrix_Classes::Real center_objval=sb->get_center_objval();
    terminated|=(center_objval-sb->get_modelval()<=
                 termeps*(CH_Matrix_Classes::abs(center_objval)+1.)*sb->get_term_corr());
    return terminated;
  }

public:
  virtual void set_defaults()
  {
    termeps=1e-5;clockp=0;timelimit.set_infinity(true);
    recomplimit=100;qpfailslimit=100;modelfailslimit=100;
    augvalfailslimit=10;oraclefailslimit=10;objevallimit=-1;
    aggregate_dnormsqr=-1.;
  }

  virtual void clear()
  { terminated=0; }
  
  BundleTerminator(const CBout* cb=0,int incr=-1):CBout(cb,incr)
  { /*save_function=0;*/ set_defaults(); clear(); }
  
  virtual ~BundleTerminator();  //implemented in bundleterminator.cxx

  virtual void set_termeps(CH_Matrix_Classes::Real teps)
  {if (teps>0.) termeps=teps;}
  virtual CH_Matrix_Classes::Real get_termeps() const {return termeps;}
  virtual void set_aggr_dnormsqr(CH_Matrix_Classes::Real sg){aggregate_dnormsqr=sg;}
  virtual CH_Matrix_Classes::Real get_aggr_dnormsqr() const {return aggregate_dnormsqr;}
  virtual void set_timelimit(const CH_Tools::Clock* cp,CH_Tools::Microseconds tl)
  {clockp=cp;timelimit=tl;}
  virtual CH_Tools::Microseconds get_timelimit() const {return timelimit;}
  virtual void set_recomplimit(CH_Matrix_Classes::Integer rl){recomplimit=rl;}
  virtual CH_Matrix_Classes::Integer get_recomplimit() const {return recomplimit;}
  virtual void set_qpfailslimit(CH_Matrix_Classes::Integer ql){qpfailslimit=ql;}
  virtual CH_Matrix_Classes::Integer get_qpfailslimit() const {return qpfailslimit;}
  virtual void set_modelfailslimit(CH_Matrix_Classes::Integer ml){modelfailslimit=ml;}
  virtual CH_Matrix_Classes::Integer get_modelfailslimit() const {return modelfailslimit;}
  virtual void set_augvalfailslimit(CH_Matrix_Classes::Integer al){augvalfailslimit=al;}
  virtual CH_Matrix_Classes::Integer get_augvalfailslimit() const {return augvalfailslimit;}
  virtual void set_objevallimit(CH_Matrix_Classes::Integer ol){objevallimit=ol;}
  virtual CH_Matrix_Classes::Integer get_objevallimit() const {return objevallimit;}
  virtual void set_oraclefailslimit(CH_Matrix_Classes::Integer ol){oraclefailslimit=ol;}
  virtual CH_Matrix_Classes::Integer get_oraclefailslimit() const {return oraclefailslimit;}

  virtual int get_terminated() const {return terminated;}
  virtual void clear_terminated() {terminated=0;}
  
  virtual void print_status(std::ostream& o) const
  {
    o<<"termination status: "<<terminated;
    if (terminated==0) { o<<" (not terminated)"<<std::endl; return;}
    if (terminated & 1){ o<<", relative precision criterion satisfied"; }
    if (terminated & 2){ o<<", timelimit exceeded"; }
    if (terminated & 4){ o<<", function reevaluation limit exceeded";} 
    if (terminated & 8){ o<<", limit of QP failures exceeded";}
    if (terminated & 16){ o<<", limit of model failures exceeded";}
    if (terminated & 32){ o<<", limit of augmented model failures exceeded";} 
    if (terminated & 64){ o<<", limit of calls to evaluation oracle exceeded";} 
    if (terminated & 128){ o<<", limit of failed oracle calls exceeded";} 
    o<<std::endl;
  }
  
  virtual std::ostream& save(std::ostream& o) const
  {
    o.precision(20);
    o<<termeps<<"\n"<<timelimit<<"\n"<<recomplimit<<"\n"<<qpfailslimit<<"\n"<<modelfailslimit<<"\n"<<augvalfailslimit<<"\n"<<objevallimit<<"\n"<<oraclefailslimit<<"\n"<<aggregate_dnormsqr<<"\n"<<terminated<<"\n";
    return o;
  }
  
  virtual std::istream& restore(std::istream& in)
  { 
    in>>termeps;
    in>>timelimit;
    in>>recomplimit;
    in>>qpfailslimit;
    in>>modelfailslimit;
    in>>augvalfailslimit;
    in>>objevallimit;
    in>>oraclefailslimit;
    in>>aggregate_dnormsqr;
    in>>terminated; 
    return in;
  }
};


}

#endif