OptBCNewtonLike.h

#ifndef OptBCNewtonLike_h
#define OptBCNewtonLike_h

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

#include "Opt.h"
#include "NLF.h"

using std::ostream;

namespace OPTPP {

class OptBCNewtonLike: 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;                       
  int m_nconvgd;                        
  bool WarmStart;

  void defaultAcceptStep(int, int);
  NEWMAT::ColumnVector defaultComputeSearch(NEWMAT::SymmetricMatrix& );

public:

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

//-------------------------------------------
// 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);}

  virtual void reset()
    {int ndim = nlprob()->getDim(); OptimizeClass::defaultReset(ndim);}

  virtual int  updateConstraints(int ) {return 0;}

//-----------------------------------------
// These have to be defined by other classes
//-----------------------------------------
  virtual int    checkConvg();

  virtual int    checkDeriv();

  virtual double computeMaxStep(NEWMAT::ColumnVector&) {return FLT_MAX;}

  virtual int    computeStep(NEWMAT::ColumnVector sk);

  virtual void   initHessian();

  virtual void   initOpt();

  virtual double initTrustRegionSize() const;

  virtual void   optimize();

  virtual void   readOptInput();

  virtual NEWMAT::SymmetricMatrix updateH(NEWMAT::SymmetricMatrix& H, int k) = 0;

//-----------------------------------------
// Non-virtual functions
//-----------------------------------------
  int checkAnalyticFDGrad() ;

  void   printStatus(char *);

  int getFevals() const {return fcn_evals;}

  int getGevals() const {return grad_evals;}

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

  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;}

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

  NEWMAT::SymmetricMatrix getHessian() const {return Hessian;}
  void setHessian(NEWMAT::SymmetricMatrix& H) {Hessian = H;}

  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 OptBCNewton1Deriv: public OptBCNewtonLike {
public:
  OptBCNewton1Deriv(): 
    OptBCNewtonLike(), mem_nlp(0){;}

  OptBCNewton1Deriv(NLP1* p): 
    OptBCNewtonLike(p->getDim()), mem_nlp(p){;}

  OptBCNewton1Deriv(NLP1* p, UPDATEFCN u): 
    OptBCNewtonLike(p->getDim(),u), mem_nlp(p)
    {update_fcn = u;}

  OptBCNewton1Deriv(NLP1* p, TOLS t): 
    OptBCNewtonLike(p->getDim(),t),  mem_nlp(p) {;}
  
  virtual ~OptBCNewton1Deriv(){;}


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

private:
  NLP1*   mem_nlp;  
};

class OptBCNewton2Deriv: public OptBCNewtonLike {
public:
  OptBCNewton2Deriv(): 
    OptBCNewtonLike(), mem_nlp(0) {;}

  OptBCNewton2Deriv(NLP2* p): 
    OptBCNewtonLike(p->getDim()), mem_nlp(p){;}

  OptBCNewton2Deriv(NLP2* p, UPDATEFCN u): 
    OptBCNewtonLike(p->getDim(),u), mem_nlp(p){ update_fcn = u; }

  OptBCNewton2Deriv(NLP2* p, TOLS t): 
    OptBCNewtonLike(p->getDim(),t), mem_nlp(p) {}

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

} // namespace OPTPP

#endif