OptGSS.h

#ifndef OptGSS_h
#define OptGSS_h

/*----------------------------------------------------------------------
  Copyright (c) 2003
 ----------------------------------------------------------------------*/

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

#ifdef WITH_MPI
#include "mpi.h"
#endif

#include "OptDirect.h"
#include "GenSet.h"
#include "Opt_PARAMS.h"

using std::cerr;

namespace OPTPP {

class OptGSS : public OptDirect {

protected:

  NLP0* nlp;    

  NLP1* nlp1;   

  NEWMAT::ColumnVector X;               

  double fX;            

  NEWMAT::ColumnVector gX;              

  double fprev; 

  double Delta; 

  double Phi;   

  double Theta; 

  double Delta_tol; 

  int Iter_max;

  bool SearchAll;

  bool computeGrad;
  
  GenSetBase* gset; 

  NEWMAT::Matrix extras;  

  bool extras_srched;
  
  bool printCOPYRIGHT;

  void printHeader();

  bool printXiter;

  bool printGiter;

  int mpi_rank; // also used in serial code

#ifdef WITH_MPI
  int mpi_size; 

  void setpid() {    // Determine MPI size and rank
    //
    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);   // C style
    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
    //
    //    mpi_size = Comm::Get_size();          // C++ style
    //    mpi_rank = Comm::Get_rank();
  }
#endif

public:

  void setParams();

  void setParams(OptGSS_params op);

  //--
  // Constructors
  //--

  OptGSS() : nlp(0), nlp1(0), gset(0)
    { strcpy(method, "Generating Set Search"); setParams(); }

  OptGSS(NLP0* p, GenSetBase* g) : nlp(p), nlp1(0), gset(g)
    { strcpy(method, "Generating Set Search with an NLP0"); setParams(); }

  OptGSS(NLP1* p, GenSetBase* g) : nlp(p), nlp1(p), gset(g)
    { strcpy(method, "Generating Set Search with an NLP1"); setParams(); }

  OptGSS(NLP0* p, GenSetBase* g, NEWMAT::Matrix& M) : 
    nlp(p), nlp1(0), gset(g), extras(M) 
    {
      strcpy(method, "Generating Set Search with an NLP0 & extra directions");
      setParams(); 
    }

  OptGSS(NLP1* p, GenSetBase* g, NEWMAT::Matrix& M) : 
    nlp(p), nlp1(p), Delta(0.0), computeGrad(true), gset(g), extras(M) { 
    strcpy(method, "Generating Set Search with an NLP1 & extra directions"); 
    setParams(); 
  }

  // Constructors with options passed in

  OptGSS(NLP0* p, GenSetBase* g, OptGSS_params op) : nlp(p), nlp1(0), gset(g)
    { strcpy(method, "Generating Set Search with an NLP0"); setParams(op); }

  OptGSS(NLP1* p, GenSetBase* g, OptGSS_params op) : nlp(p), nlp1(p), gset(g)
    { strcpy(method, "Generating Set Search with an NLP1"); setParams(op); }

  OptGSS(NLP0* p, GenSetBase* g, NEWMAT::Matrix& M, OptGSS_params op) : 
    nlp(p), nlp1(0), gset(g), extras(M) 
    {
      strcpy(method, "Generating Set Search with an NLP0 & extra directions");
      setParams(op); 
    }

  OptGSS(NLP1* p, GenSetBase* g, NEWMAT::Matrix& M, OptGSS_params op) : 
    nlp(p), nlp1(p), Delta(0.0), computeGrad(true), gset(g), extras(M) { 
    strcpy(method, "Generating Set Search with an NLP1 & extra directions"); 
    setParams(op); 
  }
  
  //--
  // Destructor(s)
  //--
  ~OptGSS(){;}

  //--
  // Attribute access methods
  //--

  void setStepSize(double s) {Delta = s;}

  void setStepTol(double s) {Delta_tol = s;}

  void setStepInc(double s) { 
    if (s>1) {Phi = s; return;}
    cerr << "Step increment factor must exceed 1.0\n";
  }

  void setStepDec(double s) { 
    if (0<s && s<1) {Theta = s; return;}
    cerr << "Step decrement factor must be in interval (0,1)\n";
  }

  void setMaxIter(int s) { Iter_max = s;}

  void setFullSearch(bool s) { SearchAll = s;}

  bool extras_searched() { return extras_srched; }

  void setPrintX(bool s) {printXiter = s;}
  void setPrintG(bool s) {printGiter = s;}
  void printCopyright(bool doit) { printCOPYRIGHT = doit; }

  void setComputeGrad(bool s) {computeGrad = s;}


  //--
  // Our internal Optimization methods
  //--

  void expandStep() { Delta *= Phi;}

  void contractStep() { Delta *= Theta; }

  void updateX(double& newfX, NEWMAT::ColumnVector& newX) { 
    fX = newfX;
    X  << newX;
  }

  bool StopCondition() { return Delta_tol > Delta;}
  int  StepCondition();

  int search();
  //  int search(bool flag=false);
  //  int searchExtras() { return search(true);  }
  //  int searchGenSet() { return search(false); }


  virtual void reset();

  //--
  // Optimization class methods
  //--

  // -- these are virtual in Optimizeclass
  virtual void initOpt();
  virtual void optimize();
  virtual int checkConvg();
  int checkConvg_fcn();
  int checkConvg_grad();

#ifdef DAKOTA_OPTPP
  virtual void printStatus(char * msg) { printStatus(msg, true);}
#else
  virtual void printStatus(char * msg) { printStatus(msg, false);}
#endif

  void printStatus(char * msg, bool printXc);

  //--
  // Define unused virtal methods from base class (OptimizeClass)
  //--
  NEWMAT::ColumnVector computeSearch(NEWMAT::SymmetricMatrix& ) 
    {return NEWMAT::ColumnVector();}

  virtual void acceptStep(int k, int step_type)
    {OptimizeClass::defaultAcceptStep(k, step_type);}

  virtual void updateModel(int k, int ndim, NEWMAT::ColumnVector x)
    {OptimizeClass::defaultUpdateModel(k, ndim, x);}

  virtual void readOptInput() {;}

  void printIter(int iter, int bp);

#ifdef WITH_MPI
  int getMPIRank() { return mpi_rank; }
  int getMPISize() { return mpi_size; }
  //  int pll_search();
#endif

};

} // namespace OPTPP
#endif