QuasiNewton.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__numerical_QuasiNewton_h__)
#define __numerical_QuasiNewton_h__

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

#ifdef DEBUG_QuasiNewton
// Debug the base class.
#ifndef DEBUG_OptGrad
#define DEBUG_OptGrad
#endif
#endif

#include "Opt.h"

#include "../../ads/tensor/SquareMatrix.h"

#include "../../geom/kernel/Point.h"

#include <cmath>

BEGIN_NAMESPACE_NUMERICAL


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

  // 
  // Private types
  //

  typedef Opt<N,Function,T,Point> base_type;

  typedef ads::SquareMatrix<N,T> matrix_type;

public:

  //
  // Public types.
  //
  
  typedef typename base_type::function_type function_type;

  typedef typename base_type::number_type number_type;

  typedef typename base_type::point_type point_type;

private:

  //
  // Member data.
  //

  number_type _x_tolerance;

  number_type _gradient_tolerance;

  //
  // Not implemented.
  //
  
  // Default constructor not implemented.
  QuasiNewton();

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

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

public:

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

  QuasiNewton( const function_type& function,
               const number_type x_tolerance 
               = 4 * std::numeric_limits<number_type>::epsilon(),
               const number_type gradient_tolerance 
               = 4 * std::numeric_limits<number_type>::epsilon(),
               const int max_function_calls = 10000 ) :
    base_type( function, max_function_calls ),
    _x_tolerance( x_tolerance ),
    _gradient_tolerance( gradient_tolerance )
  {}

  virtual
  ~QuasiNewton()
  {}

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


  void
  find_minimum( point_type& x, number_type& value, int& num_iterations,
                number_type max_step = 0,
                const number_type x_tolerance = 0,
                const number_type gradient_tolerance = 0 );
  

  void
  find_minimum( point_type& x )
  {
    number_type value;
    int num_iterations;
    find_minimum( x, value, num_iterations );
  }
  
  // @}
  //--------------------------------------------------------------------------
  // @{

  //
  // Inherited from Opt.
  //

  static
  int
  dimension()
  {
    return base_type::dimension();
  }

  const function_type&
  function() const
  {
    return base_type::function();
  }

  int
  num_function_calls() const
  {
    return base_type::num_function_calls();
  }

  //
  // New.
  //

  number_type
  x_tolerance() const
  {
    return _x_tolerance;
  }

  number_type
  gradient_tolerance() const
  {
    return _gradient_tolerance;
  }

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

  //
  // Inherited from Opt
  //

  void
  set_max_function_calls( const int max_function_calls )
  {
    base_type::set_max_function_calls( max_function_calls );
  }

  void
  reset_num_function_calls()
  {
    base_type::reset_num_function_calls();
  }

  //
  // New.
  //
  
  void
  set_x_tolerance( const number_type x_tolerance )
  {
    _x_tolerance = x_tolerance;
  }

  void
  set_gradient_tolerance( const number_type gradient_tolerance )
  {
    _gradient_tolerance = gradient_tolerance;
  }

  // @}

protected:

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


  number_type
  evaluate_function( const point_type& x )
  {
    return base_type::evaluate_function( x );
  }


  void
  evaluate_gradient( const point_type& x, point_type& gradient )
  {
    base_type::evaluate_gradient( x, gradient );
  }


  void
  evaluate_numeric_gradient( const point_type& x, 
                             point_type& gradient,
                             const number_type delta = 0.0 )
  {
    base_type::evaluate_numeric_gradient( x, gradient, delta );
  }

  // @}

private:

  void
  line_search( const point_type& x_old, const number_type f_old,
               point_type& gradient, point_type& direction, point_type& x,
               number_type& f, const number_type max_step );

};

END_NAMESPACE_NUMERICAL

#define __QuasiNewton_ipp__
#include "QuasiNewton.ipp"
#undef __QuasiNewton_ipp__

#endif

---