OptPDS.h

#ifndef Optpds_h
#define Optpds_h

/*------------------------------------------------------------------------
 Copyright (c) 2001, Sandia Corporation 
 J.C. Meza, Sandia National Laboratories meza@california.sandia.gov
 ------------------------------------------------------------------------*/

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

#ifdef HAVE_STD
#include <cstdio>
#else
#include <stdio.h>
#endif

#include "Opt.h"
#include "NLP0.h"
#include "NLP.h"

using std::ofstream;
using std::ostream;

namespace OPTPP {

class OptDirect: public OptimizeClass {
 protected:
 public:
  OptDirect(){}
  OptDirect(int n): OptimizeClass(n){}
  OptDirect(int n, TOLS t): OptimizeClass(n,t){}
  virtual ~OptDirect(){}
  virtual void acceptStep(int, int) = 0;
  virtual void updateModel(int, int, NEWMAT::ColumnVector) = 0;

  virtual int checkConvg() {return 0;}
  virtual void optimize() {}
  virtual void readOptInput() {}
  virtual void reset() {}
};

//----------------------------------------------------------------------
// Parallel Direct Search Method
//----------------------------------------------------------------------

class OptPDS: public OptDirect {

protected:
  NLP0* nlp;                    
  NEWMAT::Matrix simplex;               
  NEWMAT::ColumnVector vscales; 


  int search_scheme_size;       
  int simplex_type;             
  int reset_param;
  double tr_size;               
  double simplex_size;

  bool create_scheme_flag, first, trpds;
  char schemefile_name[80];

public:
  OptPDS(){}
  OptPDS(NLP0* p): OptDirect(p->getDim()), nlp(p),  
      simplex(p->getDim(),p->getDim()+1), vscales(p->getDim()),
      search_scheme_size(64), simplex_type(2), 
      reset_param(0), tr_size(0.0), simplex_size(0.0), create_scheme_flag(true),
      trpds(false) { strcpy(method,"PDS");
      strcpy(schemefile_name,"SCHEME");  vscales = 1.0; NEWMAT::ColumnVector x
                                                          = p->getXc();
      double perturb;
      for (int i=1; i <= p->getDim(); i++) {
        for (int j=1; j <= p->getDim()+1; j++) {
          simplex(i,j) = x(i);
        }
      }
      for (int i=1; i<= p->getDim(); i++) {
        perturb = x(i)*.01;
        simplex(i,i+1) = x(i) + perturb;
      }
  }
  
  OptPDS(NLP0* p, TOLS t): OptDirect(p->getDim(), t), nlp(p),  
      simplex(p->getDim(),p->getDim()+1), vscales(p->getDim()),
      search_scheme_size(64), simplex_type(2),
      reset_param(0), tr_size(0.0), simplex_size(0.0), create_scheme_flag(true),
      trpds(false) { strcpy(method,"PDS");
      strcpy(schemefile_name,"SCHEME"); vscales = 1.0; NEWMAT::ColumnVector x
                                                         = p->getXc();
      double perturb;
      for (int i=1; i <= p->getDim(); i++) {
        for (int j=1; j <= p->getDim()+1; j++) {
          simplex(i,j) = x(i);
        }
      }
      for (int i=1; i<=p->getDim(); i++) {
        perturb = x(i)*.01;
        simplex(i,i+1) = x(i) + perturb;
      }
  }

  virtual ~OptPDS(){}
  virtual NEWMAT::ColumnVector computeSearch(NEWMAT::SymmetricMatrix& ) 
      {return NEWMAT::ColumnVector();}

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

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

  virtual void reset() 
    {int ndim = nlp->getDim(); OptimizeClass::defaultReset(ndim);}

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

  void setSSS(int s)                 {search_scheme_size = s;}

  void setSimplexType(int t)         {simplex_type = t;}

  void setScale(NEWMAT::ColumnVector x)      {vscales = x;};

  void setSimplex(NEWMAT::Matrix &m)         {simplex = m;};

  void setCreateFlag(bool flag=true) {create_scheme_flag = flag;};

  void setSchemeFileName(char *s)    {strcpy(schemefile_name,s);};

  void setTRSize(double tr=0)        {tr_size = tr;}

  void setSimplexSize(double len)    {simplex_size = len;}

  void setNonIter(bool init=false)   {first = init;}
  void setTRPDS(bool trcon=false)   {trpds = trcon;}

  int getSimplexType()      const {return simplex_type;}
  int getSSS()              const {return search_scheme_size;}
  NEWMAT::ColumnVector& getScale()  {return vscales;};
  bool getCreateFlag()      const {return create_scheme_flag;};
  char *getSchemeFileName() {return schemefile_name;};
  double getTRSize()        {return tr_size;}
  double getSimplexSize()   {return simplex_size;}
  bool getNonIter()         {return first;}
  bool getMethod()          {return trpds;}

// These are defined elsewhere

  void initOpt();               
  void optimize();              
  void readOptInput();          
  int checkConvg();     
  void printStatus(char *);     
};

int pdsinit(NLP0 *, ostream *, int, int, int *, int *, double,
            double *, double *, double *, int *, double *, double *,
            double *, double *, double *, char *, double, int, int,
            double);

int pdsopt(NLP0 *, ostream *, double *, int *, int, char *, int, int,
           double, int, int, double, double *, double, int, double *,
           int *, char *, double, double, double *, int, int, int,
           double);

int pdswork(NLP0 *, ostream *, ofstream *, int, double, int, int, int *, 
            double, int, double *, double *, int *, double *, double *,
            int *, int, double, double *, char *, double, double, int,
            int, int, double, FILE *);

int pdschk(NLP0 *,int, double *, double *, double, double *, int, double);  

} // namespace OPTPP
#endif