iterative_solver.h

Go to the documentation of this file.

#ifndef ITERATIVE_SOLVER_H
#define ITERATIVE_SOLVER_H
#include <vector>
#include <printable.h>
#include <blitz/array.h>
#include <boost/shared_ptr.hpp>
#include <cost_func.h>
#include "observer.h"

namespace FullPhysics {

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

class IterativeSolver : 
    public Observable<IterativeSolver>,
    public Printable<IterativeSolver> {

public:


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  enum status_t {
    SUCCESS,  
    CONTINUE, 
    STALLED,  
    ERROR,    
    UNTRIED   
  };


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  IterativeSolver(int max_cost_function_calls, bool vrbs)
    : max_cost_f_calls(max_cost_function_calls),
      verbose(vrbs), stat(UNTRIED)
  {}


  virtual ~IterativeSolver() {}

//-----------------------------------------------------------------------
// Observers can be be registered to get notified for each accepted
// solver state.
//-----------------------------------------------------------------------

  virtual void add_observer(Observer<IterativeSolver>& Obs)
    { add_observer_do(Obs, *this);}

  virtual void remove_observer(Observer<IterativeSolver>& Obs)
    { remove_observer_do(Obs, *this);}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual int num_accepted_steps() const
  { return Accepted_points.size()-1; }


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual std::vector< blitz::Array<double, 1> > accepted_points() const
  { return Accepted_points; }


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual std::vector<double> cost_at_accepted_points() const
  { return Cost_at_accepted_points; }


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual void solve() = 0;


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual status_t status() const
  { return stat; }


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual const char * const status_str() const;


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  virtual void print(std::ostream& Os) const 
  { Os << "IterativeSolver"; }


protected:

  int max_cost_f_calls;

  bool verbose;
  status_t stat;

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  void record_accepted_point(const blitz::Array<double, 1>& point)
  { 
      Accepted_points.push_back(point); 

      // Notify observers, number of accepted points will be > 0 now
      notify_update_do(*this);
  }


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  void record_cost_at_accepted_point(double cost)
  { Cost_at_accepted_points.push_back(cost); }


private:

  std::vector< blitz::Array<double, 1> > Accepted_points;
  std::vector< double > Cost_at_accepted_points;

};
}
#endif