OptBCEllipsoid.h

#ifndef OptBCEllipsoid_h
#define OptBCEllipsoid_h

#include "Opt.h"

namespace OPTPP{

class OptBCEllipsoid: public OptimizeClass {
private:
  NLP1* mem_nlp;                        
  int   nlp_type;                       
  
protected:
  NLP1*   nlprob() const {return mem_nlp;} 
  double  fval_lowbound, fval_upbound; 
  double  initial_radius;              
  int     xscal_flag;                  
  int     deepcutflag;                 

public:

//----------------------------------------------------------------------
// Constructors & Destructors
//----------------------------------------------------------------------

  OptBCEllipsoid() {}

  OptBCEllipsoid(NLP1* p): OptimizeClass(p->getDim()), mem_nlp(p), 
      initial_radius(-1.0e0), xscal_flag(0), deepcutflag(0) {nlp_type = 1;}

  OptBCEllipsoid(NLP1* p, UPDATEFCN u): OptimizeClass(p->getDim()), 
      mem_nlp(p), initial_radius(-1.0e0), xscal_flag(0), deepcutflag(0) 
      {update_fcn = u; nlp_type = 1;}

  OptBCEllipsoid(NLP1* p, TOLS t): OptimizeClass(p->getDim(),t), 
      mem_nlp(p), initial_radius(-1.0e0), xscal_flag(0), deepcutflag(0) 
      {nlp_type = 1;}

  ~OptBCEllipsoid(){}

//----------------------------------------------------------------------------
// these functions have to be defined
//----------------------------------------------------------------------------

  virtual void         acceptStep(int k, int step_type);
  virtual int          checkConvg();
  NEWMAT::ColumnVector computeSearch(NEWMAT::SymmetricMatrix&) {exit(-1); return xprev;}
  virtual void         optimize();      
  virtual void         readOptInput();  

  virtual void         printStatus(char *);

  virtual void         updateModel(int k, int ndim, NEWMAT::ColumnVector x) 
      {OptimizeClass::defaultUpdateModel(k, ndim, x);}
  virtual void         reset(); 

//----------------------------------------------------------------------------
// These are defined locally 
//----------------------------------------------------------------------------

  virtual void         initOpt();

  void         setInitialEllipsoid(double rad) {initial_radius = rad;}

  double       computeFeasibility(NEWMAT::ColumnVector&);

  NEWMAT::ColumnVector computeConstraintSubgradient(NEWMAT::ColumnVector&);

  int          infeasibilityStep(NEWMAT::ColumnVector&, NEWMAT::SymmetricMatrix &, 
                 double &);

  int          halfSpaceStep(NEWMAT::ColumnVector&, NEWMAT::SymmetricMatrix &,double &);

  void         setXScale(NEWMAT::ColumnVector &x) {OptimizeClass::setXScale(x); 
                 xscal_flag = 1;}
  void         setDeepCut()               {deepcutflag = 1;}

  void         resetDeepCut()             {deepcutflag = 0;}

  double       computeGamma(double);

};

} // namespace OPTPP

#endif