JointVelocities.hpp

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