JointPositions.hpp

#pragma once
 
#include "state_representation/space/joint/JointState.hpp"
#include "state_representation/space/joint/JointVelocities.hpp"
 
namespace state_representation {
class JointVelocities;
 
class JointPositions : public JointState {
private:
  using JointState::clamp_state_variable;
 
public:
  const Eigen::VectorXd& get_velocities() const = delete;
  double get_velocity(unsigned int joint_index) const = delete;
  double get_velocity(const std::string& joint_name) const = delete;
  void set_velocities(const Eigen::VectorXd& velocities) = delete;
  void set_velocities(const std::vector<double>& velocities) = delete;
  void set_velocity(double velocity, unsigned int joint_index) const = delete;
  void set_velocity(double velocity, const std::string& joint_name) const = delete;
  const Eigen::VectorXd& get_accelerations() const = delete;
  double get_acceleration(unsigned int joint_index) const = delete;
  double get_acceleration(const std::string& joint_name) const = delete;
  void set_accelerations(const Eigen::VectorXd& accelerations) = delete;
  void set_accelerations(const std::vector<double>& accelerations) = delete;
  void set_acceleration(double acceleration, unsigned int joint_index) const = delete;
  void set_acceleration(double acceleration, const std::string& joint_name) const = delete;
  const Eigen::VectorXd& get_torques() const = delete;
  double get_torque(unsigned int joint_index) const = delete;
  double get_torque(const std::string& joint_name) const = delete;
  void set_torques(const Eigen::VectorXd& torques) = delete;
  void set_torques(const std::vector<double>& torques) = delete;
  void set_torque(double torque, unsigned int joint_index) const = delete;
  void set_torque(double torque, const std::string& joint_name) const = delete;
 
  explicit JointPositions();
 
  explicit JointPositions(const std::string& robot_name, unsigned int nb_joints = 0);
 
  explicit JointPositions(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  explicit JointPositions(const std::string& robot_name, const Eigen::VectorXd& positions);
 
  explicit JointPositions(
      const std::string& robot_name, const std::vector<std::string>& joint_names, const Eigen::VectorXd& positions
  );
 
  JointPositions(const JointPositions& positions);
 
  JointPositions(const JointState& state);
 
  JointPositions(const JointVelocities& velocities);
 
  static JointPositions Zero(const std::string& robot_name, unsigned int nb_joints);
 
  static JointPositions Zero(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  static JointPositions Random(const std::string& robot_name, unsigned int nb_joints);
 
  static JointPositions Random(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  JointPositions& operator=(const JointPositions& positions) = default;
 
  JointPositions& operator+=(const JointPositions& positions);
 
  JointPositions operator+(const JointPositions& positions) const;
 
  JointPositions& operator-=(const JointPositions& positions);
 
  JointPositions operator-(const JointPositions& positions) const;
 
  JointPositions& operator*=(double lambda);
 
  JointPositions operator*(double lambda) const;
 
  JointPositions& operator*=(const Eigen::ArrayXd& lambda);
 
  JointPositions operator*(const Eigen::ArrayXd& lambda) const;
 
  JointPositions& operator*=(const Eigen::MatrixXd& lambda);
 
  JointPositions operator*(const Eigen::MatrixXd& lambda) const;
 
  JointPositions& operator/=(double lambda);
 
  JointPositions operator/(double lambda) const;
 
  JointVelocities operator/(const std::chrono::nanoseconds& dt) const;
 
  JointPositions copy() const;
 
  Eigen::VectorXd data() const override;
 
  virtual void set_data(const Eigen::VectorXd& data) override;
 
  virtual void set_data(const std::vector<double>& data) override;
 
  void clamp(double max_absolute_value, double noise_ratio = 0.);
 
  JointPositions clamped(double max_absolute_value, double noise_ratio = 0.) const;
 
  void clamp(const Eigen::ArrayXd& max_absolute_value_array, const Eigen::ArrayXd& noise_ratio_array);
 
  JointPositions clamped(const Eigen::ArrayXd& max_absolute_value_array, const Eigen::ArrayXd& noise_ratio_array) const;
 
  friend std::ostream& operator<<(std::ostream& os, const JointPositions& positions);
 
  friend JointPositions operator*(double lambda, const JointPositions& positions);
 
  friend JointPositions operator*(const Eigen::ArrayXd& lambda, const JointPositions& positions);
 
  friend JointPositions operator*(const Eigen::MatrixXd& lambda, const JointPositions& positions);
};
}// namespace state_representation