siman.h

Go to the documentation of this file.

/*!
  \file   siman.h
  \author Klaus Holst
  \date   Jan 2005
  
  \brief  Simulated Annealing class. Written with help for "Numerical Recipes in C".
    
*/

#ifndef _SIMAN_H_
#define _SIMAN_H_

#include "linalg.h"

inline double zero(matrix const& x) { return 0.0; }

class AbstractFunction { // Abstract Class 
 public: 
  //  AbstractFunction() {}
  virtual double operator()(matrix const& args)=0;  
  //  ~AbstracFunction() {}
}; 

class Function {
 public:
  Function() { funk=zero; }
  Function(double (*f)(matrix const&), unsigned n) { funk = f; dim=n; }
  virtual ~Function() {}
  double operator()(matrix const& args) const {
    return funk(args);
  }
  unsigned getdim() const { return dim; }
 protected:
  double (*funk)(matrix const&);
  unsigned dim;
};


class SimAnneal {
public:
  SimAnneal(Function *ff, matrix simplex, 
            double temptr=0.01, unsigned it=100, double tol=0.001, 
            long s=12345, unsigned steps=10);
  
  ~SimAnneal() { } // Deconstructor
  void optimize();
  void anneal();
  void set_tt(double t) { tt = -t; }
  void calcyb() { yb = (*funk)(pb); } 
  double funceval(matrix &x) { return((*funk)(x)); }
  void set_simplex(matrix const& simplex) {
    // Probably needs som check wether p has correct dimensions. Same problem
    // with constructor.
    p = simplex;
    y = pval(simplex);
  }
  matrix get_pb() const { return pb; } // Holds best estimate of position of minimum
  double get_yb() const { return yb; } // Holds best estimate of minimum, i.e. f(pb)=yb.
  unsigned getdim() { return ndim; }
  
  
private:
  Function *funk;

  unsigned ndim; // Function depends on ndim variables

  long seed; // Random-seed
  double ftol; // Fractional convergence tolerance
  int iter; // Number of iterations
  unsigned static_iter;
  double tt; // Temperature (used in annealing-algorithm. 
                 // If temptr=0 we simply have a greedy Simplex-algorithm)

  matrix psum; // Vector with sum of columns of p.
  matrix pb; // Current best guess of minimum
  double yb; // Value of function in bp

  matrix p; // Simplex (Our annealing algorithm uses the Simplex-"Nelder-Meade"-algorithm)
  matrix y; // Values of function on vertices of p

  unsigned nosteps; // Nunber of times temperature is reduced in anneal-function.
  
  // Utility functions:
  double amotsa(int ihi, double &yhi, double const fac);
  void calc_psum();
  void amebsa();
  matrix pval(matrix const& pp); // Return vector with function values on simplex pp
 
};



///////// NON-member functions:

matrix newsimplex(matrix const& pb, double epsilon=0.5); // Returns a simplex located around point pb.

#endif // _SIMAN_H_

---