OptConstrNewtonLike.h

#ifndef OptConstrNewtonLike_h
#define OptConstrNewtonLike_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 OptConstrNewtonLike: public OptimizeClass {
protected:
  virtual NLP1* nlprob() const = 0; 
  int me;                       
  int mi;                       
  int grad_evals;               
  NEWMAT::ColumnVector gprev;           
  NEWMAT::ColumnVector z;               
  NEWMAT::ColumnVector y;               
  NEWMAT::ColumnVector s;               
  NEWMAT::ColumnVector constrType;      
  NEWMAT::ColumnVector constraintResidual; 
  NEWMAT::ColumnVector gradl;           
  NEWMAT::ColumnVector gradlprev;       
  NEWMAT::Matrix constraintGradient;    
  NEWMAT::Matrix constraintGradientPrev; 
  NEWMAT::SymmetricMatrix Hessian;      
  NEWMAT::SymmetricMatrix hessl;        
  SearchStrategy strategy;      
  DerivOption finitediff;       
  MeritFcn    mfcn;             
  real TR_size;                 
  real gradMult;                
  int searchSize;               
  real cost;                    
  void defaultAcceptStep(int, int);
  NEWMAT::ColumnVector defaultComputeSearch(NEWMAT::SymmetricMatrix& );
  bool WarmStart;
  bool feas_flag;               
  int max_feas_iter;            

public:
  OptConstrNewtonLike() {}
  OptConstrNewtonLike(int n): 
    OptimizeClass(n), me(0), mi(0), grad_evals(0),   gprev(n), 
    z(n), y(n), s(n), constrType(n), constraintResidual(n), 
    gradl(n), gradlprev(n),constraintGradient(n,n), constraintGradientPrev(n,n),
    Hessian(n), hessl(n), strategy(TrustRegion), finitediff(ForwardDiff), 
    mfcn(ArgaezTapia), TR_size(0.0), 
    gradMult(0.1), searchSize(64), cost(0.0), WarmStart(false),
    feas_flag(false), max_feas_iter(3)
    {z = 0; y = 0; s = 0;}
  OptConstrNewtonLike(int n, UPDATEFCN u): 
    OptimizeClass(n), me(0), mi(0), grad_evals(0),   gprev(n), 
    z(n), y(n), s(n), constrType(n), constraintResidual(n), 
    gradl(n), gradlprev(n),constraintGradient(n,n), constraintGradientPrev(n,n),
    Hessian(n), hessl(n), strategy(TrustRegion), finitediff(ForwardDiff), 
    mfcn(ArgaezTapia), TR_size(0.0), 
    gradMult(0.1), searchSize(64), cost(0.0), WarmStart(false),
    feas_flag(false), max_feas_iter(3)
    {update_fcn = u; z = 0; y = 0; s = 0;}
  OptConstrNewtonLike(int n, TOLS t): 
    OptimizeClass(n,t), me(0), mi(0), grad_evals(0),   gprev(n), 
    z(n), y(n), s(n), constrType(n), constraintResidual(n), 
    gradl(n), gradlprev(n),constraintGradient(n,n), constraintGradientPrev(n,n),
    Hessian(n), hessl(n), strategy(TrustRegion), finitediff(ForwardDiff), 
    mfcn(ArgaezTapia), TR_size(0.0), 
    gradMult(0.1), searchSize(64), cost(0.0), WarmStart(false),
    feas_flag(false), max_feas_iter(3)
    {z = 0; y = 0; s = 0;}
  
  virtual ~OptConstrNewtonLike(){}

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

 // These have to be defined by other classes

  virtual int  checkConvg();

  virtual int  checkDeriv();

  virtual int  computeStep(NEWMAT::ColumnVector sk);

  virtual real computeMaxStep(NEWMAT::ColumnVector sk);

  virtual void initOpt();

  virtual void initHessian();

  virtual double initTrustRegionSize() const;

  virtual void optimize();

  virtual void readOptInput();

// 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 search) {strategy = search;}
  SearchStrategy getSearchStrategy() const {return strategy;}

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

  NEWMAT::ColumnVector getEqualityMultiplier() const { return y;}
  void setEqualityMultiplier(const NEWMAT::ColumnVector& ymult) { y  = ymult;}

  NEWMAT::ColumnVector getInequalityMultiplier() const { return z;}
  void setInequalityMultiplier(const NEWMAT::ColumnVector& zmult){ z = zmult;}

  NEWMAT::ColumnVector getSlacks() const { return s;}
  void setSlacks(const NEWMAT::ColumnVector& slackVar) { s = slackVar;}

  MeritFcn getMeritFcn() const  { return mfcn;}
  virtual void setMeritFcn(MeritFcn option) { mfcn = option;}

  NEWMAT::ColumnVector getGradL() const  { return gradl;}
  virtual void setGradL(NEWMAT::ColumnVector gradl_value) { gradl = gradl_value;}

  NEWMAT::ColumnVector getGradLPrev() const  { return gradlprev;}
  virtual void setGradLPrev(NEWMAT::ColumnVector gradl_value) { gradlprev = gradl_value;}

  NEWMAT::ColumnVector getConstraintResidual() const  { return constraintResidual;}
  virtual void setConstraintResidual(const NEWMAT::ColumnVector& constraint_value) 
                       { constraintResidual = constraint_value;}

  NEWMAT::Matrix getConstraintGradient() const  { return constraintGradient;}
  virtual void setConstraintGradient(const NEWMAT::Matrix& constraint_grad) 
                       { constraintGradient = constraint_grad;}

  real getCost() const  { return cost;}
  void setCost(real value) { cost = value;}

  bool getFeasibilityRecoveryFlag() const {return feas_flag;}
  void setFeasibilityRecoveryFlag(bool flag) {feas_flag = flag;}

  int getMaxFeasIter() const {return max_feas_iter;}
  void setMaxFeasIter(int k) {max_feas_iter = k;}

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

  NEWMAT::ColumnVector computeFFK1Ind(const NEWMAT::ColumnVector& xc);
  NEWMAT::ColumnVector computeFFK2Ind(const NEWMAT::ColumnVector& xc);
  NEWMAT::ColumnVector computeTapiaInd(const NEWMAT::ColumnVector& step);

  void printStatus(char *);
  void printMultipliers(char *);
  void fPrintMultipliers(ostream *nlpout, char *);
  void fPrintSecSuff(ostream *nlpout, NEWMAT::ColumnVector& info);

  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 OptConstrNewton1Deriv: public OptConstrNewtonLike {
public:

  OptConstrNewton1Deriv() {}

  OptConstrNewton1Deriv(NLP1* p): 
    OptConstrNewtonLike(p->getDim()), mem_nlp(p) {;}
   
  OptConstrNewton1Deriv(NLP1* p, UPDATEFCN u): 
    OptConstrNewtonLike(p->getDim(),u), mem_nlp(p) {;}

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

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

class OptConstrNewton2Deriv: public OptConstrNewtonLike {
public:

  OptConstrNewton2Deriv() {}

  OptConstrNewton2Deriv(NLP2* p): 
    OptConstrNewtonLike(p->getDim()), mem_nlp(p){;}

  OptConstrNewton2Deriv(NLP2* p, UPDATEFCN u): 
    OptConstrNewtonLike(p->getDim(),u), mem_nlp(p){;}

  OptConstrNewton2Deriv(NLP2* p, TOLS t): 
    OptConstrNewtonLike(p->getDim(),t), mem_nlp(p){;}
  
  virtual ~OptConstrNewton2Deriv(){}

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

} // namespace OPTPP

#endif