optimizer.h

Go to the documentation of this file.

#ifndef _DLR_OPTIMIZER_H_
#define _DLR_OPTIMIZER_H_

#include <functional>

namespace dlr {

  namespace optimization {

    // template <std::unary_function Functor>
    template<class Functor>
    class Optimizer {
    public:
      // Typedefs for convenience
      typedef typename Functor::argument_type argument_type;

    
      typedef typename Functor::result_type result_type;

    
      Optimizer();

    
      explicit Optimizer(const Functor& functor);

    
      Optimizer(const Optimizer& source);

    
      virtual ~Optimizer();

    
      Functor objectiveFunction() {return m_functor;}

    
      Optimizer&
      operator=(const Optimizer& source);

    
      result_type
      optimalValue();

    
      argument_type
      optimum();

    
      void
      setObjectiveFunction(const Functor& functor);
    
    protected:

      virtual
      std::pair<typename Functor::argument_type, typename Functor::result_type>
      run() = 0;


      virtual
      void
      setOptimum(const typename Functor::argument_type& optimum,
                 const typename Functor::result_type& optimalValue,
                 bool needsFurtherOptimization) {
        m_optimum = optimum;
        m_optimalValue = optimalValue;
        m_needsOptimization = needsFurtherOptimization;
      }
    
    
      Functor m_functor;

      bool m_needsOptimization;

      argument_type m_optimum;

      result_type m_optimalValue;

    }; // class Optimizer

  } // namespace optimization

} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using optimization::Optimizer;

} // namespace dlr


/*******************************************************************
 * Member function definitions follow.  This would be a .cpp file
 * if it weren't templated.
 *******************************************************************/

#include <dlrNumeric/array1D.h>
#include <dlrOptimization/optimizerCommon.h>

namespace dlr {

  namespace optimization {

    // Default constructor in derived classes must initialize
    // configuration parameters to reasonable values.
    template <class Functor>
    Optimizer<Functor>::
    Optimizer()
      : m_functor(),
        m_needsOptimization(true),
        m_optimum()
    {
      // Empty
    }
    
    // Constructor which specifies the specific Functor instance to use.
    template <class Functor>
    Optimizer<Functor>::
    Optimizer(const Functor& functor)
      : m_functor(functor),
        m_needsOptimization(true),
        m_optimum()
    {
      // Empty
    }

    // Copy constructor.
    template <class Functor>
    Optimizer<Functor>::
    Optimizer(const Optimizer& source)
      : m_functor(source.m_functor),
        m_needsOptimization(source.m_needsOptimization),
        m_optimum()
    {
      copyArgumentType(source.m_optimum, m_optimum);
    }

    // Destructor.
    template <class Functor>
    Optimizer<Functor>::
    ~Optimizer()
    {
      // Empty
    }

    // Assignment operator.
    template <class Functor>
    Optimizer<Functor>&
    Optimizer<Functor>::
    operator=(const Optimizer& source)
    {
      if(&source != this) {
        m_functor = source.m_functor;
        m_needsOptimization = source.m_needsOptimization;
        copyArgumentType(source.m_optimum, m_optimum);
      }
      return *this;
    }

    // Find the optimum of the current Functor, if necessary, and
    // return the Functor value at that point.
    template <class Functor>
    typename Optimizer<Functor>::result_type
    Optimizer<Functor>::
    optimalValue()
    {
      if(m_needsOptimization==true) {
        std::pair<argument_type, result_type> optimum_optimalValue = this->run();
        this->setOptimum(
          optimum_optimalValue.first, optimum_optimalValue.second, false);
      }
      return m_optimalValue;
    }

    // Find the optimum of the current Functor, if necessary, and
    // return the Functor argument which produces that optimum.
    template <class Functor>
    typename Optimizer<Functor>::argument_type
    Optimizer<Functor>::
    optimum()
    {
      if(m_needsOptimization==true) {
        std::pair<argument_type, result_type> optimum_optimalValue = this->run();
        this->setOptimum(
          optimum_optimalValue.first, optimum_optimalValue.second, false);
      }
      return m_optimum;
    }

    // Specify the Functor instance to use for the optimization.
    template <class Functor>
    void
    Optimizer<Functor>::
    setObjectiveFunction(const Functor& functor)
    {
      m_functor = functor;
      m_needsOptimization = true;
    }

  } // namespace optimization

} // namespace dlr

#endif // #ifndef _DLR_OPTIMIZER_H_

---