Function.h

Go to the documentation of this file.

#ifndef _OCRABASE_FUNCTION_H_
#define _OCRABASE_FUNCTION_H_



//ocra includes

#include "ocra/optim/IFunction.h"
#include "ocra/optim/IFunctionProperties.h"
#include "ocra/optim/AbilitySet.h"
#include "ocra/optim/CoupledInputOutputSize.h"
#include "ocra/optim/Variable.h"
#include "ocra/optim/ObserverSubject.h"
#include "ocra/optim/NamedInstance.h"



namespace ocra
{
  class Function 
    : public ObserverSubject
    , public IFunctionProperties
    , OCRA_FUNCTION_INTERFACE_INHERITANCE(public)
    , virtual public NamedInstance
    , virtual public AbilitySet
    , virtual public CoupledInputOutputSize
  {
    // ------------------------ constructors --------------------------------------
  protected:
    Function(Variable& x, int dimension,  eFunctionLinearity linearity = LINEARITY_UNDEFINED, 
             eFunctionConvexity convexity = CONVEXITY_UNDEFINED, int continuity = CONTINUITY_UNKNOWN, 
             bool explicitlyTimeDependant=false, bool separableTimeDependancy = true);

  public:
    virtual ~Function();

  protected:
    void disconnectVariable();

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


    // ------------------------ public interface ----------------------------------
  public:
    int   getDimension() const;

    const Variable&     getVariable() const;
    Variable&           getVariable();

    template<eFunctionAbility Ability>
    void invalidate();

    void invalidateAll(int timestamp);
    void invalidateAll();

    template<eFunctionAbility Ability>
    bool isValid() const;

    template<eFunctionAbility Ability>
    bool canCompute() const;

    template<eFunctionAbility Ability>
    const typename IFunction<Ability>::return_type& get() const;


    template<eFunctionAbility Ability>
    typename IFunction<Ability>::return_sub_type get(int index) const;

    const VectorXd& getValue() const;

    double          getValue(int index) const;

    const MatrixXd& getJacobian() const;

    MatrixXdRow     getJacobian(int index) const;


    // ------------------------ public methods ------------------------------------
  public:
    virtual void updateFdot() const;

    virtual void updateFddot() const;

    virtual void updateJdotXdot() const;

    // ------------------------ protected methods ---------------------------------
  protected:
    void changeFunctionDimension(int newDimension);

    void updateInputSize(int timestamp);

    void resize();

    virtual void doUpdateInputSizeBegin();
    virtual void doUpdateInputSizeEnd();

    virtual void doUpdateDimensionBegin(int newDimension);
    virtual void doUpdateDimensionEnd(int oldDimension);

    virtual int computeDimensionFromInputSize() const;

    // ------------------------ private methods -----------------------------------
  private:
    void changeFunctionDimensionImpl(int newDimension);

    // ------------------------ protected members ---------------------------------
  protected:
    Variable&     x;                            //< the variable x

    //Shortcuts
    VectorXd&     _value;                       //< alias on IFunction<FUN_VALUE>::_val
    MatrixXd&     _jacobian;                    //< alias on IFunction<PARTIAL_X>::_val

  private:
    int           _dimension;                   //< the dimension of the image space (m in the class description)
    bool          _hasDisconnected;             //< see error prone design(tm) method disconnectVariable 

  protected:
    const int&    _dim;                         //< alias on the dimension for easy (read-only) acces by derived class

  };

  template<eFunctionAbility Ability>
  inline void Function::invalidate()
  {
    IFunction<Ability>::invalidate();
  }

  inline void Function::invalidateAll()
  {
    OCRA_APPLY_FUNCTION_ON_ALL_INTERFACE(invalidate());
  }

  inline void Function::invalidateAll(int)
  {
    invalidateAll();
  }

  template<eFunctionAbility Ability>
  inline bool Function::isValid() const
  {
    return IFunction<Ability>::isValid();
  }

  template<eFunctionAbility Ability>
  inline bool Function::canCompute() const
  {
    return IFunction<Ability>::canBeComputed();
  }

  template< eFunctionAbility Ability>
  inline const typename IFunction<Ability>::return_type& Function::get() const
  {
    return IFunction<Ability>::get(*this);
  }

  template< eFunctionAbility Ability>
  inline typename IFunction<Ability>::return_sub_type Function::get(int index) const
  {
    return IFunction<Ability>::get(*this, index);
  }


  inline const VectorXd& Function::getValue() const
  {
    return IFunction<FUN_VALUE>::get(*this);
  }

  inline double Function::getValue(int index) const
  {
    return IFunction<FUN_VALUE>::get(*this, index);
  }

  inline const MatrixXd& Function::getJacobian() const
  {
    return IFunction<PARTIAL_X>::get(*this);
  }

  inline MatrixXdRow Function::getJacobian(int index) const
  {
    return IFunction<PARTIAL_X>::get(*this, index);
  }
}

void testFunction();

#endif //_OCRABASE_FUNCTION_H_

// cmake:sourcegroup=Function