compute the gradient with default value of unconnected_gradients=0

joint angles and velocities of the robot. for CLOSED_LOOP (NOT RECOMMENDED): both joint angles and velocities are given

inner product between vectors or list(s) of tensors

reset the robot to initial configuration and velocity

forward mapping from root node to leaf nodes given environment features -------------------------------------------- :param q

vector-matrix-vector product x^T M y for tensors or lists of tensors

params obs: environment observation return policy_input: input to the policy

evaluate the geometry at leaf nodes given environment features -------------------------------------------- :param xs: list o

apply velocity control to the robot :param action: joint accelerations

get observation array :return obs: an nd array containing sin(joint angles), cos(joint angles), joint velocit

check whether the robot is in collision with obstacles :param buffer: buffer for collision checking

compute the batch_gradient with default value of unconnected_gradients=0

compute the distance between control point balls and obstacle balls :param control_points: batch_size x num_control_points x dimension, contr

return an rmp instance given type and params :param rmp_type: str, rmp type :param params: dict, rmp parameters :param dtype: str, e.

params obs: environment observation return value_input: input to the value function

reset time and simulator

solution to linear equation Ax=b in batch

homogeneous transformation matrices for the joint :param q: joint configuration :return frame: homogenous transformation matr

Homogeneous transformation matrix with roll pitch yaw.

clear the goal and obstacle objects in pybullet

recursively compute forward kinematics ------------------------ :param base_link: the name of the current base link :

randomly generate a goal for the end effector

generate a random initial configuration and joint velocities for the robot

randomly generate obstacles in the environment

the part of reward function for going to goal

the part of reward function for avoiding obstacles

the reward function :return reward: the current reward

check whether the (potentially randomly generated) goal and obstacles are in collision :param buffer: buffer for collision ch

set the joint limits for the robot

sort the joint names recursively

check wether the current episode is terminated due to either out of steps or collision

compute the distance between control point balls and obstacle boxes :param control_points: batch_size x num_control_points x dimension, contr

compute the forward kinematics --------------------------- :param q: configuration space coordinate :return x: dictio

pairwise distance between x and y in batch

params actions: output of the policy return env_actions: action to the environment

evaluating the rmp node :param x: tf.Tensor, position :param xd: tf.Tensor, velocity :param rmp_type: str, canonical

canonical rmp eval :param x: tf.Tensor position :param xd: tf.Tensor velocity :param features: dict, all selected fea

natural rmp eval :param x: tf.Tensor position :param xd: tf.Tensor velocity :param features: dict, all selected featu

Returns a rotation matrix from roll pitch yaw. ZYX convention.

topologically sort the joint names

:param urdf_joint: joint class from urdf_parser_py :param dtype: data type

:param urdf_path: path to urdf file :param link_set: list of links to compute fk :param workspace_dim: workspace dimension