GridSearch.h

#ifndef GridSearch_hpp
#define GridSearch_hpp

#include <iostream>
#include <vector>

using namespace std;

template<class functor, class real>
class GridSearch {
 protected:
  // key attributes
  int _max_number_increment;

  real _X0;
  real _dX;
  
  real (functor::*_f)(real);

  functor& _obj;

  // derived attributes

  mutable real _x_max;
  mutable int _i_max;
  mutable real _f_x_max;


  mutable real _x_min;
  mutable int _i_min;
  mutable real _f_x_min;

  mutable vector<real> _x;

  mutable vector<real> _F_x;

 public:  

  bool get_boundary_max() const {
    return (_i_max == 0 || _i_max == _max_number_increment);
  }

  bool get_boundary_min() const {
    return (_i_min == 0 || _i_min == _max_number_increment);
  }

  functor& get_functor() { return _obj;}

  GridSearch( 
    int  Max_Number_Increment,
    real X0, 
    real dX,
    functor& obj, 
    real (functor::*f)(real))
    : _max_number_increment( Max_Number_Increment), _X0(X0), _dX(dX), _f(f), _obj(obj),
    _x(Max_Number_Increment+1), _F_x(Max_Number_Increment+1)
  {

  }

  void do_iteration( bool print_results) {
    int i;
    for (i=0; i<= _max_number_increment;i++) {
      _x[i] = _X0 + _dX * i;
      _F_x[i] = (_obj.*_f)( _x[i]);
      if (i==0) {
        _i_max = _i_min = 0;
        _x_max = _x_min = _X0;
        _f_x_max = _f_x_min = _F_x[0];
      } else {
        if (_F_x[i] > _f_x_max) {
          _i_max = i;
          _x_max = _x[i];
          _f_x_max = _F_x[i];
        } else if (_F_x[i] < _f_x_min) {
          _i_min = i;
          _x_min = _x[i];
          _f_x_min = _F_x[i];
        }
      }
      if (print_results) {
        cout << i << " " << _x[i] << " " << _F_x[i] << endl;
      }
    }
  }

  real get_x_max() const { return _x_max;}
  int get_i_max() const { return _i_max;}
  real get_f_x_max() const { return _f_x_max;}

  real get_x_min() const { return _x_min;}
  int get_i_min() const { return _i_min;}
  real get_f_x_min() const { return _f_x_min;}

};


#endif

---