IFunction.h

Go to the documentation of this file.

#ifndef _OCRABASE_IFUNCTION_H_
#define _OCRABASE_IFUNCTION_H_

#ifdef WIN32
# pragma once
#endif

#include <ocra/util/MathTypes.h>
#include "ocra/optim/ocra_assert.h"
#include <iostream>
#include <vector>
#include <stdexcept>

namespace ocra
{
  enum eFunctionAbility
  {
    FUN_VALUE = 0,        //< \f$ f(x,t) \f$
    PARTIAL_X,            //< \f$ \frac{\partial f}{\partial x}(x,t) \f$
    PARTIAL_T,            //< \f$ \frac{\partial f}{\partial t}(x,t) \f$, i.e. time derivative with x considered as constant
    FUN_DOT,              //< \f$ \dot{f}(x,t) \f$, i.e. time derivative where x is a function of t. \f$ \dot{f} = \frac{\partial f}{\partial x} \dot{x} + \frac{\partial f}{\partial t} \f$
    PARTIAL_X_DOT,        //< \f$ \dot{\left(\frac{\partial f}{\partial x}\right)}(x,t) \f$
    PARTIAL_XX,           //< \f$ \frac{\partial^2 f}{\partial x^2}(x,t) \f$
    FUN_DDOT,             //< \f$ \ddot{f}(x,t) \f$
    PARTIAL_TT,           //< \f$ \frac{\partial^2 f}{\partial t^2}(x,t) \f$
    PARTIAL_TX,           //< \f$ \frac{\partial^2 f}{\partial t \partial x}(x,t) \f$
    PARTIAL_XT,           //< \f$ \frac{\partial^2 f}{\partial x \partial t}(x,t) \f$.  necessary only for non C^2 functions...
    PARTIAL_T_DOT,        //< \f$ \dot{\left(\frac{\partial f}{\partial t}\right)}(x,t) \f$
    PARTIAL_X_DOT_X_DOT,  //< \f$ \dot{\left(\frac{\partial f}{\partial x}\right)}(x,t) \dot{x} \f$
    PROP_NUMBER           //< the number of abilities
  };

  template<class T>
  struct return_type_traits
  {
    typedef int sub_type_t;
  };


  #define DECLARE_SUBTYPE_TRAITS(type, subTypeReturn, preAccess, access) \
  template<> struct return_type_traits<type > \
  { \
    typedef subTypeReturn sub_type_t; \
    static subTypeReturn getSub(const type& v, int index) {return preAccess(v.access(index));} \
    static void resize(type& v, int m, int n=0);\
  };

  DECLARE_SUBTYPE_TRAITS(VectorXd, double, /*nothing*/, operator[]);
  DECLARE_SUBTYPE_TRAITS(MatrixXd, MatrixXdRow, /*nothing*/, row);
  DECLARE_SUBTYPE_TRAITS(std::vector<MatrixXd*>, const MatrixXd&, *, operator[]);

  #undef DECLARE_SUBTYPE_TRAITS

  inline void return_type_traits<VectorXd>::resize(VectorXd& v, int m, int n) {v.resize(m);}

  inline void return_type_traits<MatrixXd>::resize(MatrixXd& v, int m, int n) {v.resize(m,n);}

  inline void return_type_traits<std::vector<MatrixXd*> >::resize(std::vector<MatrixXd*>& v, int m, int n)
  {
    ocra_assert(0<=m && "invalide size m");
    ocra_assert(0<=n && "invalide size n");
    //if the dimension decrease, we remove the supernumerary matrices.
    //entered only if m < v.size()
    for (int i=(int)v.size()-1; i>=m; --i)
    {
      delete v[i];
      v.pop_back();
    }

    //we resize the matrices
    for (size_t i=0; i<v.size(); ++i)
      v[i]->resize(n, n);

    //if the dimension increases, we add the necessary matrices.
    //entered only if m > v.size()
    for (size_t i=v.size(); i<(size_t)m; ++i)
      v.push_back(new MatrixXd(n, n));
  }

  #define DECLARE_FUNCTION_TRAITS(templateArg, propName, returnType, virtualFunctionName, abilityId) \
  template<templateArg> struct ocra_function_traits propName \
  { \
    typedef returnType type_t; \
    typedef return_type_traits<returnType>::sub_type_t sub_type_t; \
    virtual void virtualFunctionName() const \
    { \
      std::stringstream s; \
      s << "[Function::" << #virtualFunctionName << "] is not implemented. Did you forget to declare its overload as a protected const method ?"; \
      std::cout << s.str()<<std::endl; \
      throw std::runtime_error(s.str()); \
    } \
 \
    template<class FunctionType> static void update(const FunctionType& function) { function.virtualFunctionName(); } \
    static bool extractUsage(const std::vector<bool>& usageSet) {return usageSet[abilityId];}\
  };

  DECLARE_FUNCTION_TRAITS( eFunctionAbility Property, /* general */, int /*arbitrary type */, updateProperty /* arbitraryName */, -1 /* arbitrary id*/);

  DECLARE_FUNCTION_TRAITS(/* special */, <FUN_VALUE>, VectorXd, updateValue, FUN_VALUE);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_X>, MatrixXd, updateJacobian, PARTIAL_X);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_T>, VectorXd, updatePartialT, PARTIAL_T);
  DECLARE_FUNCTION_TRAITS(/* special */, <FUN_DOT>, VectorXd, updateFdot, FUN_DOT);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_X_DOT>, MatrixXd, updateJdot, PARTIAL_X_DOT);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_XX>, std::vector<MatrixXd*>, updateHessian, PARTIAL_XX);
  DECLARE_FUNCTION_TRAITS(/* special */, <FUN_DDOT>, VectorXd, updateFddot, FUN_DDOT);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_TT>, VectorXd, updatePartialTT, PARTIAL_TT);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_TX>, MatrixXd, updatePartialTX, PARTIAL_TX);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_XT>, MatrixXd, updatePartialXT, PARTIAL_XT);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_T_DOT>, VectorXd, updatePartialTdot, PARTIAL_T_DOT);
  DECLARE_FUNCTION_TRAITS(/* special */, <PARTIAL_X_DOT_X_DOT>, VectorXd, updateJdotXdot, PARTIAL_X_DOT_X_DOT);

  #undef DECLARE_FUNCTION_TRAITS



  template<eFunctionAbility Property>
  class IFunction
    : public ocra_function_traits<Property>
  {
    // ------------------------------------------------------------
    // -------------- Constructor / Destructor --------------------
    // ------------------------------------------------------------
  protected:
    IFunction(const std::vector<bool>& props)
      :ocra_function_traits<Property>()
      ,_used(ocra_function_traits<Property>::extractUsage(props))
      ,_validated(false)
    {
    };

    ~IFunction()
    {
      resizeData(0, 0);
    }

  private:
    IFunction(const IFunction&);
    IFunction& operator= (const IFunction&);

  public:
    typedef typename ocra_function_traits<Property>::type_t return_type;
    typedef typename ocra_function_traits<Property>::sub_type_t return_sub_type;

  protected:
    void invalidate() {_validated = false;}

    bool isValid() const {return _validated;}

    bool canBeComputed() const {return _used;}


    template<class FunctionType>
    const return_type& get(FunctionType& data) const
    {
      ocra_assert(_used && "this function property is not used bordel");
      if (!_validated)
      {
        ocra_function_traits<Property>::update(data);
        _validated = true;
      }
      return _val;
    }

    template<class FunctionType>
    return_sub_type get(FunctionType& data, int index) const
    {
      get(data);
      return return_type_traits<return_type>::getSub(_val, index);
    }

    void resizeData(int m, int n)
    {
      if (_used)
      {
        _validated = false;
        return_type_traits<return_type>::resize(_val, m, n);
      }
    }
  protected:
    mutable return_type _val;           //< the memory buffer to keep the result of the computation.

  private:
    mutable bool        _validated;     //< the flag to know wether _val is up-to-date or not
    bool                _used;          //< the flag indicating if this ability is used
  };


#define OCRA_FUNCTION_INTERFACE_LIST(begin, pre, end) \
  begin IFunction<FUN_VALUE> end \
  pre IFunction<PARTIAL_X> end \
  pre IFunction<PARTIAL_T> end \
  pre IFunction<FUN_DOT> end \
  pre IFunction<PARTIAL_X_DOT> end \
  pre IFunction<PARTIAL_XX> end \
  pre IFunction<FUN_DDOT> end \
  pre IFunction<PARTIAL_TT> end \
  pre IFunction<PARTIAL_TX> end \
  pre IFunction<PARTIAL_XT> end \
  pre IFunction<PARTIAL_T_DOT> end \
  pre IFunction<PARTIAL_X_DOT_X_DOT> end \
  /*pre IFunction<[NEW_PROP]> end*/

#define OCRA_FUNCTION_INTERFACE_COMA ,

#define OCRA_FUNCTION_INTERFACE_INHERITANCE(inheritanceAccessRight)\
  OCRA_FUNCTION_INTERFACE_LIST(inheritanceAccessRight, OCRA_FUNCTION_INTERFACE_COMA inheritanceAccessRight, )

#define OCRA_APPLY_FUNCTION_ON_ALL_INTERFACE(methodAndArgs) \
  OCRA_FUNCTION_INTERFACE_LIST(, ,  ::methodAndArgs;)

#define OCRA_FUNCTION_INTERFACE_INITIALIZE(usageSet)\
  OCRA_FUNCTION_INTERFACE_LIST(, OCRA_FUNCTION_INTERFACE_COMA, (usageSet))

}

#endif //_OCRABASE_IFUNCTION_H_

// cmake:sourcegroup=Function