OptNIPSLike.h

#ifndef OptNIPSLike_h
#define OptNIPSLike_h

/*----------------------------------------------------------------------
 Copyright (c) 2001, Sandia Corporation.   Under the terms of Contract 
 DE-AC04-94AL85000, there is a non-exclusive license for use of this 
 work by or on behalf of the U.S. Government.

 P.J. Williams, Sandia National Laboratories, pwillia@ca.sandia.gov
 ----------------------------------------------------------------------*/

#ifndef OptConstrNewtonLike_h
#include "OptConstrNewtonLike.h"
#endif

namespace OPTPP {

class OptNIPSLike: public OptConstrNewtonLike {
 protected:
  virtual NLP1* nlprob() const= 0; 
  real          beta_;  
  real          dirder_; 
  real          mu_;    
  real          penalty_; 
  real          sigmin_; 
  real          taumin_; 
  const real    rho_;    
  const real    sw_;    

 public:
  OptNIPSLike(): OptConstrNewtonLike(), beta_(0.0e0), 
    dirder_(0.0e0), mu_(0.0e0), penalty_(0.0e0),
    sigmin_(0.0e0), taumin_(0.0e0), rho_(0.0e0), sw_(0.0e0)
    {strcpy(method,"Nonlinear Interior-Point Method");}
  OptNIPSLike(int n): OptConstrNewtonLike(n), beta_(0.0e0), 
    dirder_(0.0e0), mu_(0.0e0), penalty_(1.0e2),
    sigmin_(0.1e0), taumin_(0.95e0), rho_(5.0e-1), sw_(1.0e2)
    { strcpy(method,"Nonlinear Interior-Point Method"); }
  OptNIPSLike(int n, UPDATEFCN u): OptConstrNewtonLike(n,u), beta_(0.0e0), 
    dirder_(0.0e0), mu_(0.0e0), penalty_(1.0e2),
    sigmin_(0.1e0), taumin_(0.95e0), rho_(5.0e-1), sw_(1.0e2)
    { strcpy(method,"Nonlinear Interior-Point Method"); }
  OptNIPSLike(int n, TOLS t): OptConstrNewtonLike(n,t), beta_(0.0e0), 
    dirder_(0.0e0), mu_(0.0e0), penalty_(1.0e2),
    sigmin_(0.1e0), taumin_(0.95e0), rho_(5.0e-1), sw_(1.0e2)
    { strcpy(method,"Nonlinear Interior-Point Method"); }

  virtual ~OptNIPSLike(){}

//-------------------------------------------------------------------
// Virtual Functions 
//-------------------------------------------------------------------

  virtual void setMeritFcn(MeritFcn option);
  virtual NEWMAT::Matrix setupMatrix(const NEWMAT::ColumnVector& xc);
  virtual real merit(int flag, const NEWMAT::ColumnVector& xc, const NEWMAT::ColumnVector& yc,
                     NEWMAT::ColumnVector& zc, NEWMAT::ColumnVector& sc);
  virtual NEWMAT::ColumnVector setupRHS(const NEWMAT::ColumnVector& xc, real mu);
  virtual NEWMAT::ColumnVector setupRHS(const NEWMAT::ColumnVector& xplus,
                                const NEWMAT::ColumnVector& yplus,
                                const NEWMAT::ColumnVector& zplus,
                                const NEWMAT::ColumnVector& splus, real mu);

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

  virtual int checkConvg();
  virtual int checkDeriv();
  virtual int computeStep(NEWMAT::ColumnVector step);

  virtual void initOpt();               
  virtual void initHessian();           
  virtual void optimize();              
  virtual void printStatus(char *s);    
  virtual void readOptInput();          

//-------------------------------------------------------------------
// Accessor Methods
//-------------------------------------------------------------------

  real getMu() const { return mu_;}
  void setMu(real newMu) { mu_ = newMu;}

  void setCenteringParameter(real newSigma) { sigmin_ = newSigma;}

  void setStepLengthToBdry(real newTau) { taumin_ = newTau;}

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

  virtual void reset();

  void recoverFeasibility(NEWMAT::ColumnVector xinit, CompoundConstraint* constraints, 
                          double ftol);
  NEWMAT::ColumnVector computeSearch2(NEWMAT::Matrix& Jacobian, const NEWMAT::ColumnVector& rhs);
  NEWMAT::ColumnVector initMultipliers(const NEWMAT::ColumnVector& df, NEWMAT::Matrix& dcon);

  void updateMu(int k);

  real merit2(int flag, const NEWMAT::ColumnVector& xc, const NEWMAT::ColumnVector& yc,
              NEWMAT::ColumnVector& zc, NEWMAT::ColumnVector& sc);
  real merit3(int flag, const NEWMAT::ColumnVector& xc, NEWMAT::ColumnVector& zc,
              NEWMAT::ColumnVector& sc);

  void computeDirDeriv(NEWMAT::ColumnVector& sk, const NEWMAT::ColumnVector& xc,
                       NEWMAT::ColumnVector& derivative);
  double dampenStep(NEWMAT::ColumnVector& step);

};

} // namespace OPTPP

#endif