DiagonalLinearFunction.h

Go to the documentation of this file.

#ifndef _OCRABASE_DIAGONAL_LINEAR_FUNCTION_H_
#define _OCRABASE_DIAGONAL_LINEAR_FUNCTION_H_

#ifdef WIN32
# pragma once
#endif

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

namespace ocra
{
  class DiagonalLinearFunction : public LinearFunction
  {
    // ------------------------ structures --------------------------------------
  public:
    typedef LinearFunction  functionType_t;     //< alias on the type of the mother class. Needed to duplicate the function tree.

    // ------------------------ constructors ------------------------------------
  private:
    DiagonalLinearFunction(const DiagonalLinearFunction&);
    DiagonalLinearFunction& operator= (const DiagonalLinearFunction&);

  public:
    template<class VectorBase1, class VectorBase2>
    DiagonalLinearFunction(Variable& x, const VectorBase1& d, const VectorBase2& b,
                           const bool useDefaultValue = false, const double defaultDiagValue = 1.,
                           const double defaultbValue = 0.);

    template<class VectorBase>
    DiagonalLinearFunction(Variable& x, const double diagonalElementValue, const VectorBase& b,
                           const bool useDefaultValue = false, const double defaultbValue = 0.);

    template<class VectorBase>
    DiagonalLinearFunction(Variable& x, const VectorBase& d, const double vectorElementValue,
                           const bool useDefaultValue = false, const double defaultDiagValue = 1.);

    DiagonalLinearFunction(Variable& x, const double diagonalElementValue, const double vectorElementValue,
                           const bool useDefaultValue = false);

  protected:
    DiagonalLinearFunction(Variable& x);


    // ------------------------ public interface --------------------------------
  public:
    inline const  VectorXd& getDiagonal()   const;
    inline double getDefaultDiagonalValue() const;
    inline double getDefaultbValue()        const;
    inline bool   isUsingDefaultValue()     const;

    void  changeDiagonal(const VectorXd& d);

    void  changeDiagonal(const double diagonalElementValue, const bool changeDefault = true);

    void  changeDefaultDiagonalValue(const double v);

    void  changeDefaultbValue(const double v);

    // ------------------------ protected methods -------------------------------
  protected:
    virtual void updateValue() const;

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

    virtual void doChangeDiagonal(const VectorXd& d);
    virtual void doChangeDiagonal(const double diagonalElementValue, const bool changeDefault = true);
    virtual void doChangeDefaultDiagonalValue(const double v);
    virtual void doChangeDefaultbValue(const double v);

    virtual void doChangeA(const MatrixXd& A);

    int computeDimensionFromInputSize() const;
    void doUpdateDimensionBegin(int newDimension);

    // ------------------------ private methods ---------------------------------
  private:
    void buildA();

    // ------------------------ protected members -------------------------------
  protected:
    VectorXd  _d;                       //< diagonal value
    double    _defaultDiagonalValue;    //< default diagonal value
    double    _defaultbValue;           //< default value to fill b
    bool      _useDefaultValue;         //< true if the default value can be used
  };


  template <class VectorBase1, class VectorBase2>
  inline DiagonalLinearFunction::DiagonalLinearFunction(Variable& x, const VectorBase1& d, const VectorBase2& b,
                                                 const bool useDefaultValue, const double defaultDiagValue,
                                                 const double defaultbValue)
    :NamedInstance("diagonal linear function")
    , AbilitySet(PARTIAL_X)
    , CoupledInputOutputSize(true)
    , LinearFunction(x, x.getSize()), _useDefaultValue(useDefaultValue), _defaultDiagonalValue(defaultDiagValue)
    , _defaultbValue(defaultbValue)
  {
    OCRA_STATIC_ASSERT_VECTOR_OR_DYNAMIC_MATRIX(VectorBase1);  //Did you put an int instead of a double ? That would explain you arrived in the wrong ctor
    ocra_assert(d.rows()==1 || d.cols()==1);
    OCRA_STATIC_ASSERT_VECTOR_OR_DYNAMIC_MATRIX(VectorBase2);  //Did you put an int instead of a double ? That would explain you arrived in the wrong ctor
    ocra_assert(b.cols()==1);

    if (d.size() != _dim)
      throw std::runtime_error("[ocra::DiagonalLinearFunction::DiagonalLinearFunction] Size of diagonal d doesn't match the variable size");

    if (b.size() != _dim)
      throw std::runtime_error("[ocra::DiagonalLinearFunction::DiagonalLinearFunction] Size of b doesn't match the variable size");

    _d = d;
    buildA();
    changeb(b);
  }


  template <class VectorBase>
  inline DiagonalLinearFunction::DiagonalLinearFunction(Variable& x, const double diagonalElementValue, const VectorBase& b,
                                                 const bool useDefaultValue, const double defaultbValue)
    :NamedInstance("diagonal linear function")
    , AbilitySet(PARTIAL_X)
    , CoupledInputOutputSize(true)
    , LinearFunction(x, x.getSize()), _useDefaultValue(useDefaultValue), _defaultDiagonalValue(diagonalElementValue)
    , _defaultbValue(defaultbValue)
  {
    OCRA_STATIC_ASSERT_VECTOR_OR_DYNAMIC_MATRIX(VectorBase); //Did you put an int instead of a double ? That would explain you arrived in the wrong ctor
    ocra_assert(b.cols()==1);

    if (b.size() != _dim)
      throw std::runtime_error("[ocra::DiagonalLinearFunction::DiagonalLinearFunction] Size of b doesn't match the variable size");

    _d.resize(_dim);
    _d.setConstant(diagonalElementValue);
    buildA();
    changeb(b);
  }


  template <class VectorBase>
  inline DiagonalLinearFunction::DiagonalLinearFunction(Variable& x, const VectorBase& d, const double vectorElementValue,
                                                 const bool useDefaultValue, const double defaultDiagValue)
    :NamedInstance("diagonal linear function")
    , AbilitySet(PARTIAL_X)
    , CoupledInputOutputSize(true)
    , LinearFunction(x, x.getSize()), _useDefaultValue(useDefaultValue), _defaultDiagonalValue(defaultDiagValue), _d(d)
    ,_defaultbValue(vectorElementValue)
  {
    OCRA_STATIC_ASSERT_VECTOR_OR_DYNAMIC_MATRIX(VectorBase); //Did you put an int instead of a double ? That would explain you arrived in the wrong ctor
    ocra_assert(d.rows()==1 || d.cols()==1);

    if (d.size() != _dim)
      throw std::runtime_error("[ocra::DiagonalLinearFunction::DiagonalLinearFunction] Size of diagonal d doesn't match the variable size");
  
    buildA();
    _b.resize(_dim);
    _b.setConstant(vectorElementValue);

  }



  inline const VectorXd& DiagonalLinearFunction::getDiagonal() const
  {
    return _d;
  }


  inline double DiagonalLinearFunction::getDefaultDiagonalValue() const
  {
    return _defaultDiagonalValue;
  }


  inline double DiagonalLinearFunction::getDefaultbValue() const
  {
    return _defaultbValue;
  }


  inline bool DiagonalLinearFunction::isUsingDefaultValue() const
  {
    return _useDefaultValue;
  }


  void testDiagonalLinearFunction();
}

#endif  //_OCRABASE_DIAGONAL_LINEAR_FUNCTION_H_

// cmake:sourcegroup=Function