OptNewtonLike.h

#ifndef OptNewtonLike_h
#define OptNewtonLike_h

/*--------------------------------------------------------------------
 Copyright (c) 2001, Sandia Corporation.
 J.C. Meza, Sandia National Laboratories, meza@ca.sandia.gov
 ---------------------------------------------------------------------*/


#include "Opt.h"

using std::ostream;

namespace OPTPP {

class OptNewtonLike: public OptimizeClass {
protected:
  virtual NLP1 *nlprob() const = 0;  
  NEWMAT::ColumnVector gprev;           
  NEWMAT::SymmetricMatrix Hessian;      
  int grad_evals;               
  SearchStrategy strategy;      
  DerivOption finitediff;       
  real TR_size;                 
  real gradMult;                
  int searchSize;               
  void defaultAcceptStep(int, int);
  NEWMAT::ColumnVector defaultComputeSearch(NEWMAT::SymmetricMatrix& );
  bool WarmStart;

public:

  OptNewtonLike() {}

  OptNewtonLike(int n): 
    OptimizeClass(n), gprev(n), Hessian(n), grad_evals(0),
    strategy(TrustRegion), finitediff(ForwardDiff), TR_size(0.0),
    gradMult(0.1), searchSize(64), WarmStart(false){}

  OptNewtonLike(int n, UPDATEFCN u): 
    OptimizeClass(n), gprev(n), Hessian(n),grad_evals(0),
    strategy(TrustRegion), finitediff(ForwardDiff),TR_size(0.0),
    gradMult(0.1), searchSize(64), WarmStart(false){update_fcn = u;}
  OptNewtonLike(int n, TOLS t): 
    OptimizeClass(n,t), gprev(n), Hessian(n), grad_evals(0),
    strategy(TrustRegion), finitediff(ForwardDiff),TR_size(0.0),
    gradMult(0.1), searchSize(64), WarmStart(false){}
  
  virtual ~OptNewtonLike(){}

//-----------------------------------------------------------------
// Virtual functions 
//-----------------------------------------------------------------

//-----------------------------------------------------------------
// These have default values
//-----------------------------------------------------------------
  virtual void acceptStep(int k, int step_type)
    {defaultAcceptStep(k, step_type);}

  virtual NEWMAT::ColumnVector computeSearch(NEWMAT::SymmetricMatrix& H )
    {return defaultComputeSearch(H);}

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

//-----------------------------------------------------------------
// These have to be defined by other classes
//-----------------------------------------------------------------

  virtual int  checkConvg();

  virtual int  checkDeriv();


  virtual int  computeStep(NEWMAT::ColumnVector sk);

  virtual void initOpt();

  virtual void initHessian();

  virtual double initTrustRegionSize() const;
 
  virtual void optimize();

  virtual void readOptInput();

  virtual void reset();

//-----------------------------------------------------------------
// These are used by all derived classes
//-----------------------------------------------------------------

  int checkAnalyticFDGrad();

  int getFevals() const {return fcn_evals;}

  int getGevals() const {return grad_evals;}

  real getTRSize() const {return TR_size;}
  void setTRSize(real delta) {TR_size = delta;}

  real getGradMult() const {return gradMult;}
  void setGradMult(real tau) {gradMult = tau;}


  int getSearchSize() const {return searchSize;}
  void setSearchSize(int sss) {searchSize = sss;}

  bool getWarmStart() const {return WarmStart;}
  void UseWarmStart(NEWMAT::SymmetricMatrix& H) {Hessian = H; WarmStart = true;}

  void setSearchStrategy(SearchStrategy s) {strategy = s;}
  SearchStrategy getSearchStrategy() const {return strategy;}

  
  void setDerivOption(DerivOption d) {finitediff = d;}
  DerivOption getDerivOption() const {return finitediff;}

  NEWMAT::SymmetricMatrix getHessian() const {return Hessian;}
  void setHessian(NEWMAT::SymmetricMatrix& H) {Hessian = H;}
  
  virtual NEWMAT::SymmetricMatrix updateH(NEWMAT::SymmetricMatrix& H, int k) = 0;

  void printStatus(char *);

  friend int trustregion(NLP1*, ostream*, NEWMAT::SymmetricMatrix&,
                         NEWMAT::ColumnVector&, NEWMAT::ColumnVector&,
                         real&, real&, real stpmax, real stpmin);

  friend int trustpds(NLP1*, ostream*, NEWMAT::SymmetricMatrix&,
                      NEWMAT::ColumnVector&, NEWMAT::ColumnVector&,
                      real&, real&, real stpmax, real stpmin, int);

};

class OptNewton1Deriv: public OptNewtonLike {
public:
  OptNewton1Deriv() {}

  OptNewton1Deriv(NLP1* p): 
    OptNewtonLike(p->getDim()), mem_nlp(p){}

  OptNewton1Deriv(NLP1* p, UPDATEFCN u): 
    OptNewtonLike(p->getDim(),u), mem_nlp(p){}

  OptNewton1Deriv(NLP1* p, TOLS t): 
    OptNewtonLike(p->getDim(),t), mem_nlp(p){}
  
  virtual ~OptNewton1Deriv(){}

private:
  NLP1* mem_nlp;
  
protected:
  NLP1* nlprob() const { return mem_nlp; }
};

class OptNewton2Deriv: public OptNewtonLike {
public:
  OptNewton2Deriv() {}

  OptNewton2Deriv(NLP2* p): 
    OptNewtonLike(p->getDim()), mem_nlp(p){}

  OptNewton2Deriv(NLP2* p, UPDATEFCN u): 
    OptNewtonLike(p->getDim(),u), mem_nlp(p){}

  OptNewton2Deriv(NLP2* p, TOLS t): 
    OptNewtonLike(p->getDim(),t), mem_nlp(p){}
  
  virtual ~OptNewton2Deriv(){}

private:
  NLP2* mem_nlp;
  
protected:
  NLP1* nlprob() const { return mem_nlp; }
  NLP2* nlprob2() const { return mem_nlp; }
};

} // namespace OPTPP

#endif