Penalty.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__numerical_Penalty_h__)
#define __numerical_Penalty_h__

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

#include "CoordinateDescent.h"
#include "FunctionWithQuadraticPenalty.h"

BEGIN_NAMESPACE_NUMERICAL


template <int N, class Function, class Constraint, 
          typename T = typename Function::result_type,
          typename Point = typename Function::argument_type>
class Penalty
{
public:

  //
  // Public types.
  //
  
  typedef Function function_type;

  typedef Constraint constraint_type;

  typedef T number_type;

  typedef Point point_type;

private:

  // The objective function with a quadratic penalty.
  typedef FunctionWithQuadraticPenalty<N, function_type, constraint_type,
                                       number_type, point_type>
  function_with_penalty_type;

  // The unconstrained optimization method.
  typedef CoordinateDescent<N, function_with_penalty_type, number_type, 
                            point_type> 
  optimization_type;

private:

  //
  // Member data.
  //

  // The objective function with a quadratic penalty.
  function_with_penalty_type _function_with_penalty;

  // The unconstrained optimization method.
  optimization_type _optimization;

  // The initial step size;
  number_type _initial_step_size;

  // The final step size;
  number_type _final_step_size;

  // The maximum allowed error in the constraint.
  number_type _max_constraint_error;

  // The initial value of the penalty parameter.
  number_type _initial_penalty_parameter;

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

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

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

public:

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

  Penalty( const function_type& function,
           const constraint_type& constraint,
           const number_type initial_step_size = 
           std::pow( std::numeric_limits<number_type>::epsilon(), 0.25 ),
           const number_type final_step_size = 
           std::sqrt( std::numeric_limits<number_type>::epsilon() ),
           const number_type max_constraint_error = 
           std::pow( std::numeric_limits<number_type>::epsilon(), 0.25 ),
           const int max_function_calls = 10000 );

  virtual
  ~Penalty()
  {}

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

  void
  find_minimum( point_type& x );

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

  number_type
  penalty_parameter() const
  {
    return _function_with_penalty.penalty_parameter();
  }

  number_type
  max_constraint_error() const
  {
    return _max_constraint_error;
  }

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

  void
  set_initial_step_size( const number_type initial_step_size )
  {
    _initial_step_size = initial_step_size;
  }

  void
  set_final_step_size( const number_type final_step_size )
  {
    _final_step_size = final_step_size;
  }

  void
  set_step_size_reduction_factor( const number_type 
                                  step_size_reduction_factor )
  {
    _optimization.set_step_size_reduction_factor( step_size_reduction_factor );
  }

  void
  set_max_constraint_error( const number_type max_constraint_error )
  {
    _max_constraint_error = max_constraint_error;
  }

  void
  set_penalty_parameter( const number_type penalty_parameter )
  {
    _optimization.function().set_penalty_parameter( penalty_parameter );
  }

  // @}

};

END_NAMESPACE_NUMERICAL

#define __Penalty_ipp__
#include "Penalty.ipp"
#undef __Penalty_ipp__

#endif

---