@@ -262,6 +262,7 @@ The classes ``SE3``, ``SO3``, ``SE2`` and ``SO2`` can provide colorized text out
 
 .. image:: ../figs/colored_output.png
    :width: 300
+
 with rotational elements in red, translational elements in blue and constants in grey.
 
 The foreground and background colors can be controlled using the following
@@ -538,8 +539,10 @@ A numpy column vector has shape ``(N,1)`` and a row vector
 has shape ``(1,N)`` but functions also accept row ``(1,N)``  and column ``(N,1)`` 
 where a vector argument is required.  
 
-.. warning:: For a user transitioning from MATLAB the most significant
-  differences are:
+.. warning::
+
+  For a user transitioning from MATLAB the most significant differences are:
+
     - the use of 1D arrays -- all MATLAB arrays have two dimensions,
       even if one of them is equal to one.
     - Iterating over a 1D NumPy array (N,) returns consecutive elements
 
@@ -338,7 +338,7 @@ def SE3(self) -> SE3:
 
         .. runblock:: pycon
 
-            >>> from spatialmath import DualQuaternion, SE3
+            >>> from spatialmath import UnitDualQuaternion, SE3
             >>> T = SE3.Rand()
             >>> print(T)
             >>> d = UnitDualQuaternion(T)
 
@@ -62,7 +62,7 @@ def isinteger(x: Any) -> bool:
 
     .. runblock:: pycon
 
-        >>> from spatialmath.base import isscalar
+        >>> from spatialmath.base import isinteger
         >>> isinteger(1)
         >>> isinteger(1.2)
 
 
@@ -115,42 +115,41 @@ def plot_point(
         Plot one or more points, with optional text label.
 
         - The color of the marker can be different to the color of the text, the
-        marker color is specified by a single letter in the marker string.
+          marker color is specified by a single letter in the marker string.
 
         - A point can have multiple markers, given as a list, which will be
-        overlaid, for instance ``["rx", "ro"]`` will give a ⨂ symbol.
+          overlaid, for instance ``["rx", "ro"]`` will give a ⨂ symbol.
 
         - The optional text label is placed to the right of the marker, and
-        vertically aligned.
+          vertically aligned.
 
         - Multiple points can be marked if ``pos`` is a 2xn array or a list of
-        coordinate pairs.  In this case:
+          coordinate pairs.  In this case:
 
             - all points have the same ``text`` label
             - ``text`` can include the format string {} which is susbstituted for the
-            point index, starting at zero
+              point index, starting at zero
             - ``text`` can be a tuple containing a format string followed by vectors
-            of shape(n).  For example::
+              of shape(n).  For example::
 
-                ``("#{0} a={1:.1f}, b={2:.1f}", a, b)``
+                ("#{0} a={1:.1f}, b={2:.1f}", a, b)
 
             will label each point with its index (argument 0) and consecutive
             elements of ``a`` and ``b`` which are arguments 1 and 2 respectively.
 
         Example::
 
-            >>> from spatialmath.base import plotvol2, plot_text
+            >>> from spatialmath.base import plotvol2, plot_point
             >>> plotvol2(5)
-            >>> plot_point((0, 0))        # plot default marker at coordinate (1,2)
+            >>> plot_point((0,0))        # plot default marker at coordinate (1,2)
             >>> plot_point((1,1), 'r*')  # plot red star at coordinate (1,2)
-            >>> plot_point((2,2), 'r*', 'foo')  # plot red star at coordinate (1,2) and
-        label it as 'foo'
+            >>> plot_point((2,2), 'r*', 'foo')  # plot red star at coordinate (1,2) and label it as 'foo'
 
         .. plot::
 
-            from spatialmath.base import plotvol2, plot_text
+            from spatialmath.base import plotvol2, plot_point
             ax = plotvol2(5)
-            plot_point((0, 0))
+            plot_point((0,0))
             plot_point((1,1), 'r*')
             plot_point((2,2), 'r*', 'foo')
             ax.grid()
@@ -846,13 +845,15 @@ def plot_ellipse(
         The ellipse is defined by :math:`x^T \mat{E} x = s^2` where :math:`x \in
         \mathbb{R}^2` and :math:`s` is the scale factor.
 
-        .. note:: For some common cases we require :math:`\mat{E}^{-1}`, for example
+        .. note::
+            For some common cases we require :math:`\mat{E}^{-1}`, for example:
+
             - for robot manipulability
-            :math:`\nu (\mat{J} \mat{J}^T)^{-1} \nu` i
+              :math:`\nu (\mat{J} \mat{J}^T)^{-1} \nu` i
             - a covariance matrix
-            :math:`(x - \mu)^T \mat{P}^{-1} (x - \mu)`
-            so to avoid inverting ``E`` twice to compute the ellipse, we flag that
-            the inverse is provided using ``inverted``.
+              :math:`(x - \mu)^T \mat{P}^{-1} (x - \mu)`
+              so to avoid inverting ``E`` twice to compute the ellipse, we flag that
+              the inverse is provided using ``inverted``.
 
         Returns a set of ``resolution``  that lie on the circumference of a circle
         of given ``center`` and ``radius``.
@@ -1101,7 +1102,7 @@ def plot_ellipsoid(
         .. note::
 
             - If a confidence interval is given then ``E`` is interpretted as a covariance
-            matrix and the ellipse size is computed using an inverse chi-squared function.
+              matrix and the ellipse size is computed using an inverse chi-squared function.
 
         :seealso: :func:`~matplotlib.pyplot.plot_surface`, :func:`~matplotlib.pyplot.plot_wireframe`
         """
 
@@ -1119,7 +1119,8 @@ def q2str(
     fmt: Optional[str] = "{: .4f}",
 ) -> str:
     """
-    Format a quaternion as a string
+    Convert quaternion to compact single-line string
+
 
     :arg q: unit-quaternion
     :type q: array_like(4)
 
@@ -61,7 +61,7 @@ def symbol(
 
             - symbols named after greek letters will appear as greek letters
             - underscore means subscript as it does in LaTex, so the symbols ``q``
-            above will be subscripted.
+              above will be subscripted.
 
         :seealso: :func:`sympy.symbols`
         """
@@ -347,7 +347,7 @@ def det(x):
         >>> R = rot2(theta)
         >>> print(R)
         >>> print(det(R))
-        >>> simplify(print(det(R)))
+        >>> print(simplify(det(R)))
 
     .. note:: Converts to a SymPy ``Matrix`` and then back again.
     """
 
@@ -715,13 +715,13 @@ def trnorm2(T: SE2Array) -> SE2Array:
     The steps in normalization are:
 
     #. If :math:`\mathbf{R} = [a, b]`
-    #. Form unit vectors :math:`\hat{b}
+    #. Form unit vectors :math:`\hat{b}`
     #. Form the orthogonal planar vector :math:`\hat{a} = [\hat{b}_y  -\hat{b}_x]`
     #. Form the normalized SO(2) matrix :math:`\mathbf{R} = [\hat{a}, \hat{b}]`
 
     .. runblock:: pycon
 
-        >>> from spatialmath.base import trnorm, troty
+        >>> from spatialmath.base import trnorm2, trot2
         >>> from numpy import linalg
         >>> T = trot2(45, 'deg', t=[3, 4])
         >>> linalg.det(T[:2,:2]) - 1 # is a valid SO(3)
@@ -796,8 +796,8 @@ def tradjoint2(T):
         >>> tr2adjoint2(T)
 
     :Reference:
-        - Robotics, Vision & Control for Python, Section 3.1, P. Corke, Springer 2023.
-        - `Lie groups for 2D and 3D Transformations <http://ethaneade.com/lie.pdf>_
+        - *Robotics, Vision & Control for Python*, Section 3.1, P. Corke, Springer 2023.
+        - `*Lie groups for 2D and 3D Transformations* <http://ethaneade.com/lie.pdf>`_
 
     :SymPy: supported
     """
@@ -882,14 +882,14 @@ def trinterp2(start, end, s, shortest: bool = True):
     :rtype: ndarray(3,3) or ndarray(2,2)
     :raises ValueError: bad arguments
 
-    - ``trinterp2(None, T, S)`` is an SE(2) matrix interpolated
-      between identity when `S`=0 and `T`  when `S`=1.
-    - ``trinterp2(T0, T1, S)`` as above but interpolated
-      between `T0` when `S`=0 and `T1` when `S`=1.
-    - ``trinterp2(None, R, S)`` is an SO(2) matrix interpolated
-      between identity when `S`=0 and `R` when `S`=1.
-    - ``trinterp2(R0, R1, S)`` as above but interpolated
-      between `R0` when `S`=0 and `R1` when `S`=1.
+    - ``trinterp2(None, T, s)`` is an sE(2) matrix interpolated
+      between identity when `s=0` and `T`  when `s=1`.
+    - ``trinterp2(T0, T1, s)`` as above but interpolated
+      between `T0` when `s=0` and `T1` when `s=1`.
+    - ``trinterp2(None, R, s)`` is an sO(2) matrix interpolated
+      between identity when `s=0` and `R` when `s=1`.
+    - ``trinterp2(R0, R1, s)`` as above but interpolated
+      between `R0` when `s=0` and `R1` when `s=1`.
 
     .. note:: Rotation angle is linearly interpolated.
 
 
@@ -326,6 +326,7 @@ def transl(x, y=None, z=None):
     .. note:: This function is compatible with the MATLAB version of the
         Toolbox.  It is unusual/weird in doing two completely different things
         inside the one function.
+
     :seealso: :func:`~spatialmath.base.transforms2d.transl2`
     :SymPy: supported
     """
@@ -3390,7 +3391,8 @@ def tranimate(T: Union[SO3Array, SE3Array], **kwargs) -> str:
         :type wait: bool
         :param movie: name of file to write MP4 movie into
         :type movie: str
-        :param **kwargs: arguments passed to ``trplot``
+        :param kwargs: arguments passed to ``trplot``
+        :type kwargs: dict
 
         - ``tranimate(T)`` where ``T`` is an SO(3) or SE(3) matrix, animates a 3D
           coordinate frame moving from the world frame to the frame ``T`` in