vector_dof.h

Go to the documentation of this file.

#ifndef OPEN_WALKER_CORE_VECTOR_DOF_H
#define OPEN_WALKER_CORE_VECTOR_DOF_H

#include <Eigen/Dense>
#include <ow_core/configuration.h>

namespace ow_core
{
template <typename _Scalar, int _Rows>
class VectorDof :
    public Eigen::Matrix<_Scalar, _Rows, 1>
{
public:
  typedef _Scalar Scalar;

  enum
  {
      Rows = _Rows,
  };

  typedef Eigen::Matrix<Scalar, Rows, 1> Base;

public:
  static typename Base::ConstantReturnType Zero()
  {
    return Base::Zero(OW_ROBOT_DOF);
  }

  static typename Base::ConstantReturnType Ones()
  {
    return Base::Ones(OW_ROBOT_DOF);
  }

  static typename Base::ConstantReturnType Constant(const Scalar& value)
  {
    return Base::Constant(OW_ROBOT_DOF,value);
  }

  static const typename Base::RandomReturnType Random()
  {
    return Base::Random(OW_ROBOT_DOF);
  }

  static const typename Base::BasisReturnType Unit(typename Base::Index i)
  {
    return Base::Unit(OW_ROBOT_DOF,i);
  }


public:
  explicit VectorDof()
  {}

  template<typename OtherDerived>
  VectorDof(const Eigen::EigenBase<OtherDerived>& other)
        : Base(other)
  {}

  using Base::operator=;


  VectorDof& setConstant(const Scalar& value)
  {
    Base::setConstant(OW_ROBOT_DOF,value);
    return *this;
  }

  VectorDof& setLinSpaced(const Scalar& low, const Scalar& high)
  {
    Base::setLinSpaced(OW_ROBOT_DOF,low,high);
    return *this;
  }

  VectorDof& setZero()
  {
    Base::setZero(OW_ROBOT_DOF);
    return *this;
  }

  VectorDof& setOnes()
  {
    Base::setOnes(OW_ROBOT_DOF);
    return *this;
  }

  VectorDof& setRandom()
  {
    Base::setRandom(OW_ROBOT_DOF);
    return *this;
  }


  std::string toString() const
  {
      std::ostringstream out;
      out << this->transpose();
      return out.str();
  }

private:

  using Base::resize;
  using Base::resizeLike;
  using Base::conservativeResize;

  using Base::LinSpaced;

};

}  // namespace ow_core


#endif  // OPEN_WALKER_CORE_VECTOR_DOF_H