OptNPSOL.h

#ifndef OptNPSOL_h
#define OptNPSOL_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.
 ----------------------------------------------------------------------*/

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

namespace OPTPP {

class OptNPSOL: public OptimizeClass {

  int             npsol_n;        
  int             npsol_nclin;    
  int             npsol_ncnln;    
  int             buf_len;        
  int             deriv_level;    
  int             lda;            
  int             ldcjac;         
  int             liwork;         
  int             lwork;          
  int             maxiter;        
  int             iter_taken;     
  int             ret_code;       
  int             *istate;        
  int             *iwork;         
  double          diff_interval;  
  double          fcn_accrcy;     
  double          *xvalue;        
  double          fvalue;         
  double          *grad;          
  double          *A;             
  double          *cfcn;          
  double          *clambda;       
  double          *cjac;          
  double          *hessian;       
  double          *lowerbounds;   
  double          *upperbounds;   
  double          *work;          
  bool            setXFlag;       
  INITFCN         initfcn;        
  USERFCN0        usrfcn0;        
  USERFCN1        usrfcn1;        
  USERNLNCON0     confcn0;        
  USERNLNCON1     confcn1;        
  Appl_Data_NPSOL *application;   

public:

  //----------------------------------------------------------------------
  // Constructors & Destructors
  //----------------------------------------------------------------------

  OptNPSOL(int n, int nclin, int ncnln, USERFCN0 f,INITFCN i) : npsol_n(n), 
           npsol_nclin(nclin), npsol_ncnln(ncnln), buf_len(1), 
           deriv_level(0), lda(nclin), ldcjac(ncnln), fvalue(1.0e30),
           setXFlag(false)  
           {initfcn = i; usrfcn0 = f; usrfcn1 = NULL; 
            confcn0 = NULL; confcn1 = NULL; application = NULL;
            xvalue=grad=A=cfcn=clambda=cjac=lowerbounds=upperbounds=NULL;
            hessian=work=NULL; istate=iwork=NULL;
           }

  OptNPSOL(int n, int nclin, int ncnln, USERFCN1 f,INITFCN i) : npsol_n(n), 
           npsol_nclin(nclin), npsol_ncnln(ncnln), buf_len(1), 
           deriv_level(0), lda(nclin), ldcjac(ncnln), fvalue(1.0e30),
           setXFlag(false) 
           {initfcn = i; usrfcn0 = NULL; usrfcn1 = f; 
            confcn0 = NULL; confcn1 = NULL; application = NULL;
            xvalue=grad=A=cfcn=clambda=cjac=lowerbounds=upperbounds=NULL;
            hessian=work=NULL; istate=iwork=NULL;
           }

  OptNPSOL(int n,int nclin,int ncnln,USERFCN0 f,INITFCN i,USERNLNCON0 c) : 
           npsol_n(n), npsol_nclin(nclin), npsol_ncnln(ncnln), buf_len(1),
           deriv_level(0), lda(nclin), ldcjac(ncnln), fvalue(1.0e30),
           setXFlag(false) 
           {initfcn = i; usrfcn0 = f; usrfcn1 = NULL; 
            confcn0 = c; confcn1 = NULL; application = NULL;
            xvalue=grad=A=cfcn=clambda=cjac=lowerbounds=upperbounds=NULL;
            hessian=work=NULL; istate=iwork=NULL;
           }

  OptNPSOL(int n,int nclin,int ncnln,USERFCN1 f,INITFCN i,USERNLNCON0 c) : 
           npsol_n(n), npsol_nclin(nclin), npsol_ncnln(ncnln), buf_len(1),
           deriv_level(0), lda(nclin), ldcjac(ncnln), fvalue(1.0e30),
           setXFlag(false) 
           {initfcn = i; usrfcn0 = NULL; usrfcn1 = f; 
            confcn0 = c; confcn1 = NULL; application = NULL;
            xvalue=grad=A=cfcn=clambda=cjac=lowerbounds=upperbounds=NULL;
            hessian=work=NULL; istate=iwork=NULL;
           }

  OptNPSOL(int n,int nclin,int ncnln,USERFCN1 f,INITFCN i,USERNLNCON1 c) : 
           npsol_n(n), npsol_nclin(nclin), npsol_ncnln(ncnln), buf_len(1),
           deriv_level(0), lda(nclin), ldcjac(ncnln), fvalue(1.0e30), 
           setXFlag(false) 
           { initfcn = i; usrfcn0 = NULL; usrfcn1 = f; 
            confcn0 = NULL; confcn1 = c; application = NULL;
            xvalue=grad=A=cfcn=clambda=cjac=lowerbounds=upperbounds=NULL;
            hessian=work=NULL; istate=iwork=NULL;
           }

  ~OptNPSOL(); 

  //----------------------------------------------------------------------
  // internal functions
  //----------------------------------------------------------------------

  void initOpt();                       
  void optimize();                      
  void allocate(int&, int&, int&,       
            int&, int&);
  void readOptInput();                  
  void printStatus(char *);             
  void setX(const NEWMAT::ColumnVector&);       
  void setLower(const NEWMAT::ColumnVector&);   
  void setUpper(const NEWMAT::ColumnVector&);   
  void setMatrix(const NEWMAT::Matrix&);        
  void setDerivativeLevel(int &);       
  void setDifferenceInterval(double &); 
  void setFcnAccrcy(double &);          
  

  //----------------------------------------------------------------------
  // other functions that need to be defined to get around the pure
  // virtual function complaints from the compiler
  //----------------------------------------------------------------------

  virtual void  acceptStep(int, int ) { }
  virtual int   checkConvg()          {return 0;}
  virtual NEWMAT::ColumnVector computeSearch(NEWMAT::SymmetricMatrix& ) 
                                      {return (NEWMAT::ColumnVector) 0;}
  virtual void  updateModel(int k, int ndim, NEWMAT::ColumnVector x)
    {OptimizeClass::defaultUpdateModel(k, ndim, x);}
  virtual void reset(){;}

};

} // namespace OPTPP

#endif