Objective.h

Go to the documentation of this file.

#ifndef _OCRABASE_OBJECTIVE_H_
#define _OCRABASE_OBJECTIVE_H_

#ifdef WIN32
# pragma once
#endif

// includes
#include "ocra/optim/Variable.h"
#include "ocra/optim/Function.h"
#include "ocra/optim/FunctionInterfaceMapping.h"

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include "ocra/optim/SquaredLinearFunction.h"

namespace ocra
{
  template<class T>
  class Objective
    : public Objective<typename T::functionType_t>
    , public FunctionInterfaceMapping<Objective<T> >
  {
  private:
    typedef Objective<typename T::functionType_t> ObjectiveBase;
    Objective(const Objective&);
    Objective& operator= (const Objective&);

  public:
    Objective(T* function, double weight=1.);

    inline operator const T& () {return static_cast<T&>(ObjectiveBase::getFunction());}

    inline virtual T& getFunction(void) {return static_cast<T&>(ObjectiveBase::getFunction());}
    inline virtual const T& getFunction(void) const {return static_cast<const T&>(ObjectiveBase::getFunction());}

  private:
    typedef boost::is_base_of<Function, T> T_must_derived_from_Function;
    BOOST_STATIC_ASSERT(T_must_derived_from_Function           ::value);
  };



  template<>
  class Objective<Function> 
    : public FunctionInterfaceMapping<Objective<Function> >
  {
    // ------------------------ constructors ------------------------------------
  private:
    Objective(const Objective&);
    Objective& operator= (const Objective&);

  public:
    Objective(Function* function, double weight=1.);

    // ------------------------ public interface --------------------------------
  public:
    inline virtual Function& getFunction() {return _function;}
    inline virtual const Function& getFunction() const {return _function;}

    double getWeight() const;
    void   setWeight(double weight);
    // void changeWeight(const Eigen::VectorXd& weight);

  protected:
    Function& _function;  //< the function on which the constaint is built

  private:
    double    _weight;
  };

  
  template<class T>
  inline Objective<T>::Objective(T* function, double weight)
    : Objective<typename T::functionType_t>(function, weight)
  {}

  inline Objective<Function>::Objective(Function* function, double weight)
    : _function(*function), _weight(weight)
  {}


  inline double Objective<Function>::getWeight() const
  {
    return _weight;
  }

  inline void Objective<Function>::setWeight(double weight)
  {
    _weight = weight;
  }

  // inline void Objective<SquaredLinearFunction>::changeWeight(const Eigen::VectorXd& weight)
  // {
  //   _function.changeWeight(weight);
  // }
  
}



#include "ocra/optim/LinearFunction.h"
#include "ocra/optim/QuadraticFunction.h"

namespace ocra
{
  typedef Objective<Function>              GenericObjective;
  typedef Objective<LinearFunction>        LinearObjective;
  typedef Objective<QuadraticFunction>     QuadraticObjective;
  typedef Objective<SquaredLinearFunction>     SquaredLinearObjective;
}


#endif //_OCRABASE_OBJECTIVE_H_

// cmake:sourcegroup=Constraint