Opt.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__numerical_Opt_h__)
#define __numerical_Opt_h__

// If we are debugging the whole numerical package.
#if defined(DEBUG_numerical) && !defined(DEBUG_Opt)
#define DEBUG_Opt
#endif

#include "Exception.h"

#include "../derivative/centered_difference.h"

#include "../../ads/array/FixedArray.h"

BEGIN_NAMESPACE_NUMERICAL


template<int N, class Function, typename T = typename Function::result_type,
         typename Point = typename Function::argument_type>
class Opt {
protected:

  //
  // Protected types.
  //
  
  typedef Function function_type;

  typedef T number_type;

  typedef Point point_type;

  //
  // Member data.
  //

protected:

  const function_type& _function;

  int _max_function_calls;

  int _num_function_calls;

  bool _are_checking_function_calls;

  //
  // Not implemented.
  //
  
private:

  // Default constructor not implemented.
  Opt();

  // Copy constructor not implemented.
  Opt(const Opt&);

  // Assignment operator not implemented.
  Opt&
  operator=(const Opt&);

protected:

  //--------------------------------------------------------------------------
  // @{

  Opt(const function_type& function, 
      const int max_function_calls = 10000,
      const bool are_checking_function_calls = true) :
    _function(function),
    _max_function_calls(max_function_calls),
    // Do this so they remember to call reset_num_function_calls().
    _num_function_calls(std::numeric_limits<int>::max()),
    _are_checking_function_calls(are_checking_function_calls)
  {}

  virtual
  ~Opt()
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{


  number_type
  evaluate_function(const point_type& x) {
    increment_function_calls(x);
    return _function(x);
  }


  void
  evaluate_gradient(const point_type& x, point_type& gradient) {
    increment_function_calls(x);
    _function.gradient(x, gradient);
  }


  void
  evaluate_numeric_gradient(const point_type& x, 
                            point_type& gradient,
                            const number_type delta = 0.0) {
    increment_function_calls(x, 2 * N);
    if (delta != 0.0) {
      numerical::gradient_centered_difference<N,function_type,number_type>
        (_function, x, gradient, delta);
    }
    else {
      numerical::gradient_centered_difference<N,function_type,number_type>
        (_function, x, gradient);
    }
  }

  // @}

public:

  //--------------------------------------------------------------------------
  // @{

  static
  int
  dimension() {
    return N;
  }

  const function_type&
  function() const {
    return _function;
  }

  int 
  max_function_calls() {
    return _max_function_calls;
  }

  int
  num_function_calls() const {
    return _num_function_calls;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  set_max_function_calls(const int max_function_calls) {
    _max_function_calls = max_function_calls;
  }

  void
  reset_num_function_calls() {
    _num_function_calls = 0;
  }

  void
  set_are_checking_function_calls(const bool are_checking) {
    _are_checking_function_calls = are_checking;
  }

  // @}
  
private:

  // CONTINUE: Remove the x parameter.
  void
  increment_function_calls(const point_type& x, const int increment = 1) {
    _num_function_calls += increment;
    if (_are_checking_function_calls &&
        _num_function_calls > _max_function_calls) {
      OptimizationException<N,number_type,point_type>
        ex("In Opt: max function calls exceeded.",
            x, _function(x), _num_function_calls);
      ex.print();
      throw ex;
    }
  }

};

END_NAMESPACE_NUMERICAL

#endif

---