JointTorques.hpp

#pragma once
 
#include "state_representation/space/joint/JointState.hpp"
#include "state_representation/space/joint/JointPositions.hpp"
#include "state_representation/space/joint/JointVelocities.hpp"
#include "state_representation/space/joint/JointAccelerations.hpp"
 
namespace state_representation {
 
class JointPositions;
class JointVelocities;
class JointAccelerations;
 
class JointTorques : public JointState {
public:
  const Eigen::VectorXd& get_positions() const = delete;
  double get_position(unsigned int joint_index) const = delete;
  double get_position(const std::string& joint_name) const = delete;
  void set_positions(const Eigen::VectorXd& positions) = delete;
  void set_positions(const std::vector<double>& positions) = delete;
  void set_position(double position, unsigned int joint_index) const = delete;
  void set_position(double position, const std::string& joint_name) const = delete;
  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;
  JointState& operator+=(const JointPositions& positions) = delete;
  JointState& operator+=(const JointVelocities& velocities) = delete;
  JointState& operator+=(const JointAccelerations& accelerations) = delete;
  JointState operator+(const JointPositions& positions) const = delete;
  JointState operator+(const JointVelocities& velocities) const = delete;
  JointState operator+(const JointAccelerations& accelerations) const = delete;
  JointState& operator-=(const JointPositions& positions) = delete;
  JointState& operator-=(const JointVelocities& velocities) = delete;
  JointState& operator-=(const JointAccelerations& accelerations) = delete;
  JointState operator-(const JointPositions& positions) const = delete;
  JointState operator-(const JointVelocities& velocities) const = delete;
  JointState operator-(const JointAccelerations& accelerations) const = delete;
 
  explicit JointTorques();
 
  explicit JointTorques(const std::string& robot_name, unsigned int nb_joints = 0);
 
  explicit JointTorques(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  explicit JointTorques(const std::string& robot_name, const Eigen::VectorXd& torques);
 
  explicit JointTorques(const std::string& robot_name, const std::vector<std::string>& joint_names,
                        const Eigen::VectorXd& torques);
 
  JointTorques(const JointTorques& torques);
 
  JointTorques(const JointState& state);
 
  static JointTorques Zero(const std::string& robot_name, unsigned int nb_joints);
 
  static JointTorques Zero(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  static JointTorques Random(const std::string& robot_name, unsigned int nb_joints);
 
  static JointTorques Random(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  JointTorques& operator=(const JointTorques& torques) = default;
 
  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.);
 
  void clamp(const Eigen::ArrayXd& max_absolute_value_array, const Eigen::ArrayXd& noise_ratio_array);
 
  JointTorques clamped(double max_absolute_value, double noise_ratio = 0.) const;
 
  JointTorques clamped(const Eigen::ArrayXd& max_absolute_value_array, const Eigen::ArrayXd& noise_ratio_array) const;
 
  JointTorques copy() const;
 
  JointTorques& operator*=(double lambda);
 
  JointTorques operator*(double lambda) const;
 
  friend JointTorques operator*(double lambda, const JointTorques& torques);
 
  friend JointTorques operator*(const Eigen::MatrixXd& lambda, const JointTorques& torques);
 
  JointTorques& operator/=(double lambda);
 
  JointTorques operator/(double lambda) const;
 
  JointTorques& operator+=(const JointTorques& torques);
 
  JointTorques& operator+=(const JointState& state);
 
  JointTorques operator+(const JointTorques& torques) const;
 
  JointState operator+(const JointState& state) const;
 
  JointTorques operator-() const;
 
  JointTorques& operator-=(const JointTorques& torques);
 
  JointTorques& operator-=(const JointState& state);
 
  JointTorques operator-(const JointTorques& torques) const;
 
  JointState operator-(const JointState& state) const;
 
  friend std::ostream& operator<<(std::ostream& os, const JointTorques& torques);
 
private:
  using JointState::clamp_state_variable;
};
}// namespace state_representation