NLP0.h

#ifndef NLP0_h
#define NLP0_h

#ifdef HAVE_CONFIG_H
#include "OPT++_config.h"
#endif

#include "NLPBase.h"
#include "Appl_Data.h"
#include "CompoundConstraint.h"

using std::ostream;

namespace OPTPP {

class NLP0: public NLPBase{ 

protected:
  int          dim;                     
  NEWMAT::ColumnVector mem_xc;          
  real         fvalue;                  
  char         nlp_name[80];            
  NEWMAT::ColumnVector mem_fcn_accrcy;  
  int          nfevals;                 
  int          is_expensive;            
  bool         debug_;                  
  bool         modeOverride;            
  double       function_time;           
  CompoundConstraint* constraint_;      
  NEWMAT::ColumnVector  constraint_value;
  int          ncnln;                   
  Appl_Data    application;
  DerivOption finitediff;               
  SpecOption SpecFlag;                  
  NEWMAT::ColumnVector partial_grad;
  double specF;

public:
#ifdef WITH_MPI

// Constructors
  NLP0():
    dim(0),mem_xc(0),fvalue(1.0e30), mem_fcn_accrcy(0),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(0), constraint_value(0), ncnln(0), partial_grad(0)
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = Spec1;}
  NLP0(int ndim):
    dim(ndim),mem_xc(ndim),fvalue(1.0e30), mem_fcn_accrcy(ndim),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(0), constraint_value(0), ncnln(0), partial_grad(ndim)
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = Spec1;}
  NLP0(int ndim, int nlncons):
    dim(ndim),mem_xc(ndim),fvalue(1.0e30), mem_fcn_accrcy(ndim),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(0), constraint_value(nlncons), ncnln(nlncons),
    partial_grad(ndim)
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = Spec1; constraint_value = 0;}
  NLP0(int ndim, CompoundConstraint* constraint):
    dim(ndim),mem_xc(ndim),fvalue(1.0e30), mem_fcn_accrcy(ndim),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(constraint), constraint_value(0), ncnln(0), partial_grad(ndim) 
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = Spec1;}

#else
      
// Constructors
  NLP0():
    dim(0),mem_xc(0),fvalue(1.0e30), mem_fcn_accrcy(0),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(0), constraint_value(0), ncnln(0), partial_grad(0) 
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = NoSpec;}
  NLP0(int ndim):
    dim(ndim),mem_xc(ndim),fvalue(1.0e30), mem_fcn_accrcy(ndim),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(0), constraint_value(0), ncnln(0), partial_grad(ndim)
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = NoSpec;}
  NLP0(int ndim, int nlncons):
    dim(ndim),mem_xc(ndim),fvalue(1.0e30), mem_fcn_accrcy(ndim),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(0), constraint_value(nlncons), ncnln(nlncons),
    partial_grad(ndim)
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = NoSpec; constraint_value = 0;}
  NLP0(int ndim, CompoundConstraint* constraint):
    dim(ndim),mem_xc(ndim),fvalue(1.0e30), mem_fcn_accrcy(ndim),
    nfevals(0),is_expensive(0),debug_(0), modeOverride(0), function_time(0.0), 
    constraint_(constraint), constraint_value(0), ncnln(0),
    partial_grad(ndim) 
    {mem_xc = 0; mem_fcn_accrcy = DBL_EPSILON; finitediff = ForwardDiff;
    SpecFlag = NoSpec;}

#endif

  virtual void setX(const int i, const real& x)  {mem_xc(i) = x;}
  virtual void setX(const NEWMAT::ColumnVector& x)       {mem_xc = x;}

  virtual void setF(const real& fx)              {fvalue = fx;}

  virtual void setIsExpensive(const int e)       {is_expensive = e;}
  virtual void setFcnAccrcy(const int i, const real& accrcy)  
                                                   {mem_fcn_accrcy(i)=accrcy;}
  virtual void setFcnAccrcy(const NEWMAT::ColumnVector& accrcy) {mem_fcn_accrcy=accrcy;}

  virtual int  getDim()                 const {return dim;}
  virtual int  getFevals()              const {return nfevals;}
  virtual int  getIsExpensive()         const {return is_expensive;}

  virtual void setModeOverride(bool override_mode) {modeOverride = override_mode;}
   virtual bool getModeOverride() const {return modeOverride;}

  virtual real getF()                   const {return fvalue;}
  virtual NEWMAT::ColumnVector getFcnAccrcy()   const {return mem_fcn_accrcy;}
  virtual NEWMAT::ColumnVector getXc()          const {return mem_xc;}
  virtual real getFcnTime()             const {return function_time;}

// Debugging tools
  virtual void setDebug()       {debug_ = true;}
  virtual bool getDebug()       const {return debug_;}

  // Set and get the finite differencing options.

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

  // Set and get the speculative gradient options.

  void setSpecOption(SpecOption SpecEval) {SpecFlag = SpecEval;}
  SpecOption getSpecOption() const {return SpecFlag;}

// Function to reset parameter values 
  virtual void reset() = 0;   

// Functions for evaluating the objective fcn 
  virtual void initFcn() = 0;   
  virtual void eval()    = 0;
  virtual real evalF()   = 0;
  virtual real evalF(const NEWMAT::ColumnVector& x) = 0;

  // Constraint helper functions
  int  getNumOfCons()  const { return constraint_->getNumOfCons();}
  int  getNumOfNLCons()  const { return constraint_->getNumOfNLCons();}
  NEWMAT::ColumnVector  getConstraintValue()  const { return constraint_value;}
  void  setConstraintValue(const NEWMAT::ColumnVector& cfx)  { constraint_value = cfx;}
  bool hasConstraints();
  void printConstraints();
  CompoundConstraint* getConstraints() { return constraint_;}
  void setConstraints(CompoundConstraint* constraintSet) 
                { constraint_ = constraintSet;}

  virtual ~NLP0() {;}        

//------------------------------------------------------------------------
// These are defined elsewhere
//------------------------------------------------------------------------

  NEWMAT::ColumnVector FDGrad(const NEWMAT::ColumnVector &, 
    const NEWMAT::ColumnVector &, double &, NEWMAT::ColumnVector &);        
  NEWMAT::ColumnVector BDGrad(const NEWMAT::ColumnVector &, 
    const NEWMAT::ColumnVector &, double &, NEWMAT::ColumnVector &);
  NEWMAT::ColumnVector CDGrad(const NEWMAT::ColumnVector &,
    const NEWMAT::ColumnVector &, double &, NEWMAT::ColumnVector &);
  NEWMAT::SymmetricMatrix FD2Hessian(NEWMAT::ColumnVector &);

  NEWMAT::Matrix CONFDGrad(const NEWMAT::ColumnVector &);        
  NEWMAT::Matrix CONBDGrad(const NEWMAT::ColumnVector &);        
  NEWMAT::Matrix CONCDGrad(const NEWMAT::ColumnVector &);        

  virtual NEWMAT::ColumnVector evalG() = 0;
  virtual NEWMAT::ColumnVector evalG(const NEWMAT::ColumnVector& x) = 0;
  virtual NEWMAT::SymmetricMatrix evalH() = 0;
  virtual NEWMAT::SymmetricMatrix evalH(NEWMAT::ColumnVector& x) = 0;

  virtual real evalLagrangian(const NEWMAT::ColumnVector& x, NEWMAT::ColumnVector& mult,
    const NEWMAT::ColumnVector& type) = 0;
  virtual NEWMAT::ColumnVector evalLagrangianGradient(const NEWMAT::ColumnVector& x,
    const NEWMAT::ColumnVector& mult, const NEWMAT::ColumnVector& type) = 0;

  virtual NEWMAT::ColumnVector evalCF(const NEWMAT::ColumnVector& x) = 0;
  virtual NEWMAT::Matrix  evalCG(const NEWMAT::ColumnVector& x) = 0;
  virtual NEWMAT::SymmetricMatrix evalCH(NEWMAT::ColumnVector& x) = 0;
  virtual OptppArray<NEWMAT::SymmetricMatrix> evalCH(NEWMAT::ColumnVector& x, int darg) = 0;
  virtual void evalC(const NEWMAT::ColumnVector& x) = 0;

  virtual void printState(char *); 
  virtual void fPrintState(ostream *, char *); 
  void saveState(); 
};

} // namespace OPTPP
#endif