naren200
diff --git a/‎roboticstoolbox/robot/ERobot.py
Lines changed: 0 additions & 270 deletions b/‎roboticstoolbox/robot/ERobot.py
Lines changed: 0 additions & 270 deletions
@@ -1518,276 +1518,6 @@ def get_path(self, end=None, start=None):
 
         return path, n, tool
 
-    def fkine(
-        self,
-        q: ArrayLike,
-        end: Union[str, Link, Gripper, None] = None,
-        start: Union[str, Link, Gripper, None] = None,
-        tool: Union[ndarray, SE3, None] = None,
-        include_base: bool = True,
-    ) -> SE3:
-        """
-        Forward kinematics
-
-        :param q: Joint coordinates
-        :type q: ArrayLike
-        :param end: end-effector or gripper to compute forward kinematics to
-        :param start: the link to compute forward kinematics from
-        :param tool: tool transform, optional
-
-        :return: The transformation matrix representing the pose of the
-            end-effector
-
-        - ``T = robot.fkine(q)`` evaluates forward kinematics for the robot at
-          joint configuration ``q``.
-        **Trajectory operation**:
-
-        If ``q`` has multiple rows (mxn), it is considered a trajectory and the
-        result is an ``SE3`` instance with ``m`` values.
-        .. note::
-            - For a robot with a single end-effector there is no need to
-              specify ``end``
-            - For a robot with multiple end-effectors, the ``end`` must
-              be specified.
-            - The robot's base tool transform, if set, is incorporated
-              into the result.
-            - A tool transform, if provided, is incorporated into the result.
-            - Works from the end-effector link to the base
-
-        :references:
-            - Kinematic Derivatives using the Elementary Transform
-              Sequence, J. Haviland and P. Corke
-        """
-        return SE3(
-            self.ets(start, end).fkine(
-                q, base=self._T, tool=tool, include_base=include_base
-            ),
-            check=False,
-        )
-
-    def jacob0(
-        self,
-        q: ArrayLike,
-        end: Union[str, Link, Gripper, None] = None,
-        start: Union[str, Link, Gripper, None] = None,
-        tool: Union[ndarray, SE3, None] = None,
-    ) -> ndarray:
-        r"""
-        Manipulator geometric Jacobian in the base frame
-
-        :param q: Joint coordinate vector
-        :type q: ArrayLike
-        :param end: the particular link or gripper whose velocity the Jacobian
-            describes, defaults to the end-effector if only one is present
-        :param start: the link considered as the base frame, defaults to the robots's base frame
-        :param tool: a static tool transformation matrix to apply to the
-            end of end, defaults to None
-
-        :return J: Manipulator Jacobian in the base frame
-
-        - ``robot.jacobo(q)`` is the manipulator Jacobian matrix which maps
-          joint  velocity to end-effector spatial velocity expressed in the
-          end-effector frame.
-
-        End-effector spatial velocity :math:`\nu = (v_x, v_y, v_z, \omega_x, \omega_y, \omega_z)^T`
-        is related to joint velocity by :math:`{}^{E}\!\nu = \mathbf{J}_m(q) \dot{q}`.
-
-        Example:
-        .. runblock:: pycon
-            >>> import roboticstoolbox as rtb
-            >>> puma = rtb.models.ETS.Puma560()
-            >>> puma.jacobe([0, 0, 0, 0, 0, 0])
-
-        .. warning:: This is the geometric Jacobian as described in texts by
-            Corke, Spong etal., Siciliano etal.  The end-effector velocity is
-            described in terms of translational and angular velocity, not a
-            velocity twist as per the text by Lynch & Park.
-
-        .. warning:: ``start`` and ``end`` must be on the same branch,
-            with ``start`` closest to the base.
-        """  # noqa
-        return self.ets(start, end).jacob0(q, tool=tool)
-
-    def jacobe(
-        self,
-        q: ArrayLike,
-        end: Union[str, Link, Gripper, None] = None,
-        start: Union[str, Link, Gripper, None] = None,
-        tool: Union[ndarray, SE3, None] = None,
-    ) -> ndarray:
-        r"""
-        Manipulator geometric Jacobian in the end-effector frame
-
-        :param q: Joint coordinate vector
-        :type q: ArrayLike
-        :param end: the particular link or Gripper whose velocity the Jacobian
-            describes, defaults to the end-effector if only one is present
-        :param start: the link considered as the base frame, defaults to the robots's base frame
-        :param tool: a static tool transformation matrix to apply to the
-            end of end, defaults to None
-
-        :return J: Manipulator Jacobian in the end-effector frame
-
-        - ``robot.jacobe(q)`` is the manipulator Jacobian matrix which maps
-          joint  velocity to end-effector spatial velocity expressed in the
-          end-effector frame.
-        End-effector spatial velocity :math:`\nu = (v_x, v_y, v_z, \omega_x, \omega_y, \omega_z)^T`
-        is related to joint velocity by :math:`{}^{E}\!\nu = \mathbf{J}_m(q) \dot{q}`.
-
-        Example:
-        .. runblock:: pycon
-            >>> import roboticstoolbox as rtb
-            >>> puma = rtb.models.ETS.Puma560()
-            >>> puma.jacobe([0, 0, 0, 0, 0, 0])
-
-        .. warning:: This is the **geometric Jacobian** as described in texts by
-            Corke, Spong etal., Siciliano etal.  The end-effector velocity is
-            described in terms of translational and angular velocity, not a
-            velocity twist as per the text by Lynch & Park.
-
-        .. warning:: ``start`` and ``end`` must be on the same branch,
-            with ``start`` closest to the base.
-        """  # noqa
-        return self.ets(start, end).jacobe(q, tool=tool)
-
-    def hessian0(
-        self,
-        q: Union[ArrayLike, None] = None,
-        end: Union[str, Link, Gripper, None] = None,
-        start: Union[str, Link, Gripper, None] = None,
-        J0: Union[ndarray, None] = None,
-        tool: Union[ndarray, SE3, None] = None,
-    ) -> ndarray:
-        r"""
-        Manipulator Hessian
-
-        The manipulator Hessian tensor maps joint acceleration to end-effector
-        spatial acceleration, expressed in the world-coordinate frame. This
-        function calulcates this based on the ETS of the robot. One of J0 or q
-        is required. Supply J0 if already calculated to save computation time
-
-        :param q: The joint angles/configuration of the robot (Optional,
-            if not supplied will use the stored q values).
-        :type q: ArrayLike
-        :param end: the final link/Gripper which the Hessian represents
-        :param start: the first link which the Hessian represents
-        :param J0: The manipulator Jacobian in the 0 frame
-        :param tool: a static tool transformation matrix to apply to the
-            end of end, defaults to None
-        
-        :return: The manipulator Hessian in 0 frame
-        
-        This method computes the manipulator Hessian in the base frame.  If
-        we take the time derivative of the differential kinematic relationship
-        .. math::
-            \nu    &= \mat{J}(\vec{q}) \dvec{q} \\
-            \alpha &= \dmat{J} \dvec{q} + \mat{J} \ddvec{q}
-        where
-        .. math::
-            \dmat{J} = \mat{H} \dvec{q}
-        and :math:`\mat{H} \in \mathbb{R}^{6\times n \times n}` is the
-        Hessian tensor.
-
-        The elements of the Hessian are
-        .. math::
-            \mat{H}_{i,j,k} =  \frac{d^2 u_i}{d q_j d q_k}
-        where :math:`u = \{t_x, t_y, t_z, r_x, r_y, r_z\}` are the elements
-        of the spatial velocity vector.
-        Similarly, we can write
-        .. math::
-            \mat{J}_{i,j} = \frac{d u_i}{d q_j}
-        
-        :references:
-            - Kinematic Derivatives using the Elementary Transform
-              Sequence, J. Haviland and P. Corke
-        """
-        return self.ets(start, end).hessian0(q, J0=J0, tool=tool)
-
-    def hessiane(
-        self,
-        q: Union[ArrayLike, None] = None,
-        end: Union[str, Link, Gripper, None] = None,
-        start: Union[str, Link, Gripper, None] = None,
-        Je: Union[ndarray, None] = None,
-        tool: Union[ndarray, SE3, None] = None,
-    ) -> ndarray:
-        r"""
-        Manipulator Hessian
-
-        The manipulator Hessian tensor maps joint acceleration to end-effector
-        spatial acceleration, expressed in the ee frame. This
-        function calulcates this based on the ETS of the robot. One of Je or q
-        is required. Supply Je if already calculated to save computation time
-
-        :param q: The joint angles/configuration of the robot (Optional,
-            if not supplied will use the stored q values).
-        :type q: ArrayLike
-        :param end: the final link/Gripper which the Hessian represents
-        :param start: the first link which the Hessian represents
-        :param Je: The manipulator Jacobian in the ee frame
-        :param tool: a static tool transformation matrix to apply to the
-            end of end, defaults to None
-        
-        :return: The manipulator Hessian in ee frame
-        
-        This method computes the manipulator Hessian in the ee frame.  If
-        we take the time derivative of the differential kinematic relationship
-        .. math::
-            \nu    &= \mat{J}(\vec{q}) \dvec{q} \\
-            \alpha &= \dmat{J} \dvec{q} + \mat{J} \ddvec{q}
-        where
-        .. math::
-            \dmat{J} = \mat{H} \dvec{q}
-        and :math:`\mat{H} \in \mathbb{R}^{6\times n \times n}` is the
-        Hessian tensor.
-
-        The elements of the Hessian are
-        .. math::
-            \mat{H}_{i,j,k} =  \frac{d^2 u_i}{d q_j d q_k}
-        where :math:`u = \{t_x, t_y, t_z, r_x, r_y, r_z\}` are the elements
-        of the spatial velocity vector.
-        Similarly, we can write
-        .. math::
-            \mat{J}_{i,j} = \frac{d u_i}{d q_j}
-        
-        :references:
-            - Kinematic Derivatives using the Elementary Transform
-              Sequence, J. Haviland and P. Corke
-        """
-        return self.ets(start, end).hessiane(q, Je=Je, tool=tool)
-
-    def partial_fkine0(
-        self,
-        q: ArrayLike,
-        n: int = 3,
-        end: Union[str, Link, Gripper, None] = None,
-        start: Union[str, Link, Gripper, None] = None,
-    ):
-        r"""
-        Manipulator Forward Kinematics nth Partial Derivative
-
-        The manipulator Hessian tensor maps joint acceleration to end-effector
-        spatial acceleration, expressed in the ee frame. This
-        function calulcates this based on the ETS of the robot. One of Je or q
-        is required. Supply Je if already calculated to save computation time
-
-        :param q: The joint angles/configuration of the robot (Optional,
-            if not supplied will use the stored q values).
-        :type q: ArrayLike
-        :param end: the final link/Gripper which the Hessian represents
-        :param start: the first link which the Hessian represents
-        :param tool: a static tool transformation matrix to apply to the
-            end of end, defaults to None
-
-        :return: The nth Partial Derivative of the forward kinematics
-
-        :references:
-            - Kinematic Derivatives using the Elementary Transform
-              Sequence, J. Haviland and P. Corke
-        """
-
-        return self.ets(start, end).partial_fkine0(q, n=n)
-
     def link_collision_damper(
         self,
         shape,