OptLBFGS.h

#ifndef OptLBFGS_h
#define OptLBFGS_h

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

#ifndef Opt_h
#include "Opt.h"
#endif

namespace OPTPP {

class OptLBFGSLike: public OptimizeClass {
 protected:
  virtual NLP1 *nlprob() const = 0;

  NEWMAT::ColumnVector gprev;           

  int grad_evals;               

  SearchStrategy strategy;      

 public:
  OptLBFGSLike(){}
  OptLBFGSLike(int n): OptimizeClass(n), 
                    gprev(n), grad_evals(0), strategy(LineSearch){}
  OptLBFGSLike(int n, TOLS t): OptimizeClass(n,t),
                            gprev(n),grad_evals(0), strategy(LineSearch){}

  virtual ~OptLBFGSLike(){}

  void setSearchStrategy(SearchStrategy s) {strategy = s;}

  SearchStrategy getSearchStrategy() const {return strategy;}

  virtual void acceptStep(int, int) = 0;
  virtual int checkConvg();
  virtual int checkDeriv();
  virtual void optimize() {} 
  virtual void readOptInput() {}
  virtual void updateModel(int, int, NEWMAT::ColumnVector) = 0;

};

class OptLBFGS: public OptLBFGSLike {
private:
  NLP1* nlp;    

  int memM;     

  bool printXs; 

protected:
  NLP1* nlprob() const { return nlp; }

  void initMem(int n) {

    if (n>=30) {memM = 15; return;}
    if (n>= 2) {memM =  2; return;}
    if (n>= 5) {memM =  3; return;}
    if (n>=10) {memM =  5; return;}
    if (n>=20) {memM = 10; return;}
    memM = 1;
  }

public:

  OptLBFGS(): memM(15), printXs(false) {strcpy(method,"Limited Memory BFGS method");}

  OptLBFGS(NLP1* p): OptLBFGSLike(p->getDim()), nlp(p), printXs(false)
    {strcpy(method,"Limited Memory BFGS method"); initMem(p->getDim());}

  OptLBFGS(NLP1* p, int m): OptLBFGSLike(p->getDim()), nlp(p), printXs(false) {
      strcpy(method,"Limited Memory BFGS method");
      memM = (m <= p->getDim())? m : p->getDim();
  }

  OptLBFGS(NLP1* p, TOLS t): OptLBFGSLike(p->getDim(),t), nlp(p), printXs(false)
    {strcpy(method,"Limited Memory BFGS method"); initMem(p->getDim());}

  OptLBFGS(NLP1* p, TOLS t, int m): OptLBFGSLike(p->getDim(),t), nlp(p), printXs(false) {
      strcpy(method,"Limited Memory BFGS method");
      memM = (m <= p->getDim())? m : p->getDim();
  }

  virtual ~OptLBFGS(){}

  virtual 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);}

  void setPrintFinalX(bool b) { printXs = b;}

  //--
  // Defined in OptLBFGS.C:
  //--
  virtual int checkDeriv();                    
  virtual int computeStep(NEWMAT::ColumnVector& sk, double stp=1.0);   
  virtual void reset();                       
  virtual void initOpt();                     
  virtual void optimize();                    
  virtual real stepTolNorm() const;  
  virtual void printStatus(char *c);  
  virtual void printIter(int, double, double, double, double, int);
};

} // namespace OPTPP
#endif