JointAccelerations.hpp

#pragma once
 
#include "state_representation/space/joint/JointState.hpp"
#include "state_representation/space/joint/JointVelocities.hpp"
 
namespace state_representation {
class JointVelocities;
 
class JointAccelerations : public JointState {
private:
  using JointState::clamp_state_variable;
 
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& accelerations) = delete;
  void set_velocities(const std::vector<double>& accelerations) = 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_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 JointAccelerations();
 
  explicit JointAccelerations(const std::string& robot_name, unsigned int nb_joints = 0);
 
  explicit JointAccelerations(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  explicit JointAccelerations(const std::string& robot_name, const Eigen::VectorXd& accelerations);
 
  explicit JointAccelerations(
      const std::string& robot_name, const std::vector<std::string>& joint_names, const Eigen::VectorXd& accelerations
  );
 
  JointAccelerations(const JointAccelerations& accelerations);
 
  JointAccelerations(const JointState& state);
 
  JointAccelerations(const JointVelocities& velocities);
 
  static JointAccelerations Zero(const std::string& robot_name, unsigned int nb_joints);
 
  static JointAccelerations Zero(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  static JointAccelerations Random(const std::string& robot_name, unsigned int nb_joints);
 
  static JointAccelerations Random(const std::string& robot_name, const std::vector<std::string>& joint_names);
 
  JointAccelerations& operator=(const JointAccelerations& accelerations) = default;
 
  JointAccelerations& operator+=(const JointAccelerations& accelerations);
 
  JointAccelerations operator+(const JointAccelerations& accelerations) const;
 
  JointAccelerations& operator-=(const JointAccelerations& accelerations);
 
  JointAccelerations operator-(const JointAccelerations& accelerations) const;
 
  JointAccelerations& operator*=(double lambda);
 
  JointAccelerations operator*(double lambda) const;
 
  JointAccelerations& operator*=(const Eigen::ArrayXd& lambda);
 
  JointAccelerations operator*(const Eigen::ArrayXd& lambda) const;
 
  JointAccelerations& operator*=(const Eigen::MatrixXd& lambda);
 
  JointAccelerations operator*(const Eigen::MatrixXd& lambda) const;
 
  JointAccelerations& operator/=(double lambda);
 
  JointAccelerations operator/(double lambda) const;
 
  JointVelocities operator*(const std::chrono::nanoseconds& dt) const;
 
  JointAccelerations 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.);
 
  JointAccelerations 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);
 
  JointAccelerations clamped(
      const Eigen::ArrayXd& max_absolute_value_array, const Eigen::ArrayXd& noise_ratio_array
  ) const;
 
  friend std::ostream& operator<<(std::ostream& os, const JointAccelerations& accelerations);
 
  friend JointAccelerations operator*(double lambda, const JointAccelerations& accelerations);
 
  friend JointAccelerations operator*(const Eigen::ArrayXd& lambda, const JointAccelerations& accelerations);
 
  friend JointAccelerations operator*(const Eigen::MatrixXd& lambda, const JointAccelerations& accelerations);
 
  friend JointVelocities operator*(const std::chrono::nanoseconds& dt, const JointAccelerations& accelerations);
};
}// namespace state_representation