FunctionWithQuadraticPenalty.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__numerical_FunctionWithQuadraticPenalty_h__)
#define __numerical_FunctionWithQuadraticPenalty_h__

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

#include "../defs.h"

#include <functional>

#include <cassert>

BEGIN_NAMESPACE_NUMERICAL


template <int N, class Function, class Constraint, 
          typename T = typename Function::result_type,
          typename Point = typename Function::argument_type>
class FunctionWithQuadraticPenalty :
  public std::unary_function<Point,T>
{
private:

  typedef std::unary_function<Point,T> base_type;

public:

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

  typedef typename base_type::result_type result_type;

private:

  //
  // Private types.
  //
  
  // The function type.
  typedef Function function_type;

  // The constraint type.
  typedef Constraint constraint_type;

  // The number type.
  typedef result_type number_type;

  // A point in N dimensions.
  typedef argument_type point_type;

private:

  //
  // Member data.
  //

  // The objective function.
  const function_type& _function;

  // The constraint function.
  const constraint_type& _constraint;

  // The penalty parameter.
  mutable number_type _penalty_parameter;

  // The penalty parameter reduction factor.
  mutable number_type _reduction_factor;

  //
  // Not implemented.
  //

  // Default constructor not implemented.
  FunctionWithQuadraticPenalty();

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

public:

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

  FunctionWithQuadraticPenalty( const function_type& function, 
                                const constraint_type& constraint, 
                                const number_type penalty_parameter = 1,
                                const number_type reduction_factor = 0.1 );

  FunctionWithQuadraticPenalty( const FunctionWithQuadraticPenalty& x );

  virtual
  ~FunctionWithQuadraticPenalty()
  {}

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

  result_type
  operator()( const argument_type& x ) const;

  void
  gradient( const argument_type& x, argument_type& gradient ) const;

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

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

  const constraint_type&
  constraint() const
  {
    return _constraint;
  }

  number_type 
  penalty_parameter() const
  {
    return _penalty_parameter;
  }

  number_type 
  reduction_factor() const
  {
    return _reduction_factor;
  }

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

  void
  increase_penalty() const
  {
    _penalty_parameter *= _reduction_factor;
  }

  void
  set_penalty_parameter( const number_type penalty_parameter ) const
  {
    _penalty_parameter = penalty_parameter;
  }

  void
  set_reduction_factor( const number_type reduction_factor ) const
  {
    _reduction_factor = reduction_factor;
  }

  // @}
};

END_NAMESPACE_NUMERICAL

#define __FunctionWithQuadraticPenalty_ipp__
#include "FunctionWithQuadraticPenalty.ipp"
#undef __FunctionWithQuadraticPenalty_ipp__

#endif

---