sync 2026-10-29 07:40 GMT (part 7)

v12x/pylib/scipy-1.18.1.dist-info/sboms/auditwheel.cdx.json

@@ -0,0 +1 @@
+{"bomFormat": "CycloneDX", "specVersion": "1.4", "version": 1, "metadata": {"component": {"type": "library", "bom-ref": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "name": "scipy", "version": "1.18.1", "purl": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"}, "tools": [{"name": "auditwheel", "version": "6.7.0"}]}, "components": [{"type": "library", "bom-ref": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "name": "scipy", "version": "1.18.1", "purl": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650", "name": "libgfortran", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa", "name": "libquadmath", "version": "8.5.0-28.el8_10.alma.1", "purl": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1"}], "dependencies": [{"ref": "pkg:pypi/scipy@1.18.1?file_name=scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", "dependsOn": ["pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650", "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa"]}, {"ref": "pkg:rpm/almalinux/libgfortran@8.5.0-28.el8_10.alma.1#3362720ce454cc402813e3cfe54f0eb4efaedcd690fa35129ddc4b3de40e0650"}, {"ref": "pkg:rpm/almalinux/libquadmath@8.5.0-28.el8_10.alma.1#97b91febe2a1c7927c6482d6bd6567b83be3467f33c9d2764df1283f7ac9a5fa"}]}

v12x/pylib/scipy/spatial/transform/__init__.py

@@ -0,0 +1,31 @@
+"""
+Spatial Transformations (:mod:`scipy.spatial.transform`)
+========================================================
+
+.. currentmodule:: scipy.spatial.transform
+
+This package implements various spatial transformations. For now, rotations
+and rigid transforms (rotations and translations) are supported.
+
+Rotations in 3 dimensions
+-------------------------
+.. autosummary::
+   :toctree: generated/
+
+   RigidTransform
+   Rotation
+   Slerp
+   RotationSpline
+"""
+from ._rotation import Rotation, Slerp
+from ._rigid_transform import RigidTransform
+from ._rotation_spline import RotationSpline
+
+# Deprecated namespaces, to be removed in v2.0.0
+from . import rotation
+
+__all__ = ['Rotation', 'Slerp', 'RotationSpline', 'RigidTransform']
+
+from scipy._lib._testutils import PytestTester
+test = PytestTester(__name__)
+del PytestTester

v12x/pylib/scipy/spatial/transform/_rigid_transform.py

@@ -0,0 +1,1975 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from types import EllipsisType, GenericAlias, ModuleType, NotImplementedType
+from collections.abc import Callable
+
+import numpy as np
+
+from scipy._lib._array_api import (
+    array_namespace,
+    is_numpy,
+    ArrayLike,
+    Array,
+    xp_capabilities,
+)
+from scipy.spatial.transform import Rotation
+from scipy.spatial.transform._rotation import _promote
+import scipy.spatial.transform._rigid_transform_cy as cython_backend
+import scipy.spatial.transform._rigid_transform_xp as xp_backend
+import scipy._external.array_api_extra as xpx
+from scipy._external.array_api_compat import device
+from scipy._lib._array_api import xp_promote
+from scipy._lib._util import broadcastable
+
+
+__all__ = ["RigidTransform"]
+
+backend_registry = {array_namespace(np.empty(0)): cython_backend}
+
+
+def select_backend(xp: ModuleType, cython_compatible: bool):
+    """Select the backend for the given array library.
+
+    We need this selection function because the Cython backend for numpy does not
+    support quaternions of arbitrary dimensions. We therefore only use the Array API
+    backend for numpy if we are dealing with rotations of more than one leading
+    dimension.
+    """
+    if is_numpy(xp) and not cython_compatible:
+        return xp_backend
+    return backend_registry.get(xp, xp_backend)
+
+
+@xp_capabilities()
+def normalize_dual_quaternion(dual_quat: ArrayLike) -> Array:
+    """Normalize dual quaternion."""
+    xp = array_namespace(dual_quat)
+    dual_quat = _promote(dual_quat, xp=xp)
+    single = dual_quat.ndim == 1 and is_numpy(xp)
+    if single:
+        dual_quat = xpx.atleast_nd(dual_quat, ndim=2, xp=xp)
+    cython_compatible = dual_quat.ndim < 3
+    dq = select_backend(xp, cython_compatible).normalize_dual_quaternion(dual_quat)
+    if single:
+        return dq[0]
+    return dq
+
+
+rigid_transform_extra_note = (
+    """The method ``apply`` is not supported with cupy<14.*.
+
+    """)
+
+
+@xp_capabilities(
+    skip_backends=[("dask.array", "missing linalg.cross/det functions")],
+    method_capabilities={
+        "__init__": dict(
+            jax_jit=False,
+            skip_backends=[("dask.array", "missing linalg.cross/det functions")],
+        ),
+        "from_matrix": dict(
+            jax_jit=False,
+            skip_backends=[("dask.array", "missing linalg.cross/det functions")],
+        ),
+        "__getitem__": dict(
+            jax_jit=False,
+            skip_backends=[
+                ("dask.array", "cannot handle zero-length rigid transforms")
+            ],
+        ),
+        "__setitem__": dict(
+            jax_jit=False,
+            skip_backends=[
+                ("dask.array", "cannot handle zero-length rigid transforms")
+            ],
+        ),
+        "apply": dict(
+            skip_backends=[
+                ("dask.array", "missing linalg.cross/det functions"),
+                ("cupy", "missing .mT attribute in cupy<14.*"),
+            ],
+        ),
+    },
+    extra_note=rigid_transform_extra_note,
+)
+class RigidTransform:
+    """
+    Rigid transform in 3 dimensions.
+
+    This class provides an interface to initialize from and represent rigid
+    transforms (rotation and translation) in 3D space. In different fields,
+    this type of transform may be referred to as "*pose*" (especially in
+    robotics), "*extrinsic parameters*", or the "*model matrix*" (especially in
+    computer graphics), but the core concept is the same: a rotation and
+    translation describing the orientation of one 3D coordinate frame relative
+    to another. Mathematically, these transforms belong to the Special
+    Euclidean group SE(3), which encodes rotation (SO(3)) plus translation.
+
+    The following operations on rigid transforms are supported:
+
+    - Application on vectors
+    - Transformation composition
+    - Transformation inversion
+    - Transformation indexing
+
+    Note that coordinate systems must be right-handed. Because of this, this
+    class more precisely represents *proper* rigid transformations in SE(3)
+    rather than rigid transforms in E(3) more generally [1]_.
+
+    Indexing within a transform is supported since multiple transforms can be
+    stored within a single `RigidTransform` instance.
+
+    Multiple transforms can be stored in a single `RigidTransform` object, which can be
+    initialized using N-dimensional arrays and supports broadcasting for all
+    operations.
+
+    To create `RigidTransform` objects use ``from_...`` methods (see examples
+    below). ``RigidTransform(...)`` is not supposed to be instantiated directly.
+
+    For rigorous introductions to rigid transforms, see [2]_, [3]_, and [4]_.
+
+    Parameters
+    ----------
+    matrix : array_like, shape (..., 4, 4)
+        A single transformation matrix or a stack of transformation
+        matrices.
+    normalize : bool, optional
+        If True, orthonormalize the rotation matrix using singular value
+        decomposition. If False, the rotation matrix is not checked for
+        orthogonality or right-handedness.
+    copy : bool, optional
+        If True, copy the input matrix. If False, a reference to the input
+        matrix is used. If normalize is True, the input matrix is always
+        copied regardless of the value of copy.
+
+    Attributes
+    ----------
+    single
+    rotation
+    translation
+
+    Methods
+    -------
+    __len__
+    __getitem__
+    __mul__
+    __pow__
+    from_matrix
+    from_rotation
+    from_translation
+    from_components
+    from_exp_coords
+    from_dual_quat
+    as_matrix
+    as_components
+    as_exp_coords
+    as_dual_quat
+    concatenate
+    mean
+    apply
+    inv
+    identity
+
+    Notes
+    -----
+    .. versionadded:: 1.16.0
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Rigid_transformation
+    .. [2] https://motion.cs.illinois.edu/RoboticSystems/CoordinateTransformations.html
+    .. [3] https://www.brainvoyager.com/bv/doc/UsersGuide/CoordsAndTransforms/SpatialTransformationMatrices.html
+    .. [4] Kevin M. Lynch and Frank C. Park, "Modern Robotics: Mechanics,
+           Planning, and Control" Chapter 3.3, 2017, Cambridge University Press.
+           https://hades.mech.northwestern.edu/images/2/25/MR-v2.pdf#page=107.31
+    .. [5] Paul Furgale, "Representing Robot Pose: The good, the bad, and the
+           ugly", June 9, 2014.
+           https://rpg.ifi.uzh.ch/docs/teaching/2024/FurgaleTutorial.pdf
+
+    Examples
+    --------
+    A `RigidTransform` instance can be initialized in any of the above formats
+    and converted to any of the others. The underlying object is independent of
+    the representation used for initialization.
+
+    **Notation Conventions and Composition**
+
+    The notation here largely follows the convention defined in [5]_. When we
+    name transforms, we read the subscripts from right to left. So ``tf_A_B``
+    represents a transform A <- B and can be interpreted as:
+
+    - the coordinates and orientation of B relative to A
+    - the transformation of points from B to A
+    - the pose of B described in A's coordinate system
+
+    .. parsed-literal::
+        :class: highlight-none
+
+        tf_A_B
+           ^ ^
+           | |
+           | --- from B
+           |
+           ----- to A
+
+    When composing transforms, the order is important. Transforms are not
+    commutative, so in general ``tf_A_B * tf_B_C`` is not the same as
+    ``tf_B_C * tf_A_B``. Transforms are composed and applied to vectors
+    right-to-left. So ``(tf_A_B * tf_B_C).apply(p_C)`` is the same as
+    ``tf_A_B.apply(tf_B_C.apply(p_C))``.
+
+    When composed, transforms should be ordered such that the multiplication
+    operator is surrounded by a single frame, so the frame "cancels out" and
+    the outside frames are left. In the example below, B cancels out and the
+    outside frames A and C are left. Or to put it another way, A <- C is the
+    same as A <- B <- C.
+
+    .. parsed-literal::
+        :class: highlight-none
+
+                      ----------- B cancels out
+                      |      |
+                      v      v
+        tf_A_C = tf_A_B * tf_B_C
+                    ^          ^
+                    |          |
+                    ------------ to A, from C are left
+
+    When we notate vectors, we write the subscript of the frame that the vector
+    is defined in. So ``p_B`` means the point ``p`` defined in frame B. To
+    transform this point from frame B to coordinates in frame A, we apply the
+    transform ``tf_A_B`` to the vector, lining things up such that the notated
+    B frames are next to each other and "cancel out".
+
+    .. parsed-literal::
+        :class: highlight-none
+
+                   ------------ B cancels out
+                   |         |
+                   v         v
+        p_A = tf_A_B.apply(p_B)
+                 ^
+                 |
+                 -------------- A is left
+
+    **Visualization**
+
+    >>> from scipy.spatial.transform import RigidTransform as Tf
+    >>> from scipy.spatial.transform import Rotation as R
+    >>> import numpy as np
+
+    The following function can be used to plot transforms with Matplotlib
+    by showing how they transform the standard x, y, z coordinate axes:
+
+    >>> import matplotlib.pyplot as plt
+    >>> colors = ("#FF6666", "#005533", "#1199EE")  # Colorblind-safe RGB
+    >>> def plot_transformed_axes(ax, tf, name=None, scale=1):
+    ...     r = tf.rotation
+    ...     t = tf.translation
+    ...     loc = np.array([t, t])
+    ...     for i, (axis, c) in enumerate(zip((ax.xaxis, ax.yaxis, ax.zaxis),
+    ...                                       colors)):
+    ...         axlabel = axis.axis_name
+    ...         axis.set_label_text(axlabel)
+    ...         axis.label.set_color(c)
+    ...         axis.line.set_color(c)
+    ...         axis.set_tick_params(colors=c)
+    ...         line = np.zeros((2, 3))
+    ...         line[1, i] = scale
+    ...         line_rot = r.apply(line)
+    ...         line_plot = line_rot + loc
+    ...         ax.plot(line_plot[:, 0], line_plot[:, 1], line_plot[:, 2], c)
+    ...         text_loc = line[1]*1.2
+    ...         text_loc_rot = r.apply(text_loc)
+    ...         text_plot = text_loc_rot + t
+    ...         ax.text(*text_plot, axlabel.upper(), color=c,
+    ...                 va="center", ha="center")
+    ...     ax.text(*tf.translation, name, color="k", va="center", ha="center",
+    ...             bbox={"fc": "w", "alpha": 0.8, "boxstyle": "circle"})
+
+    **Defining Frames**
+
+    Let's work through an example.
+
+    First, define the "world frame" A, also called the "base frame".
+    All frames are the identity transform from their own perspective.
+
+    >>> tf_A = Tf.identity()
+
+    We will visualize a new frame B in A's coordinate system. So we need to
+    define the transform that converts coordinates from frame B to frame A
+    (A <- B).
+
+    Physically, let's imagine constructing B from A by:
+
+    1) Rotating A by +90 degrees around its x-axis.
+    2) Translating the rotated frame 2 units in A's -x direction.
+
+    From A's perspective, B is at [-2, 0, 0] and rotated +90 degrees about the
+    x-axis, which is exactly the transform A <- B.
+
+    >>> t_A_B = np.array([-2, 0, 0])
+    >>> r_A_B = R.from_euler('xyz', [90, 0, 0], degrees=True)
+    >>> tf_A_B = Tf.from_components(t_A_B, r_A_B)
+
+    Let's plot these frames.
+
+    >>> fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    >>> plot_transformed_axes(ax, tf_A, name="tfA")     # A plotted in A
+    >>> plot_transformed_axes(ax, tf_A_B, name="tfAB")  # B plotted in A
+    >>> ax.set_title("A, B frames with respect to A")
+    >>> ax.set_aspect("equal")
+    >>> ax.figure.set_size_inches(6, 5)
+    >>> plt.show()
+
+    Now let's visualize a new frame C in B's coordinate system.
+    Let's imagine constructing C from B by:
+
+    1) Translating B by 2 units in its +z direction.
+    2) Rotating B by +30 degrees around its z-axis.
+
+    >>> t_B_C = np.array([0, 0, 2])
+    >>> r_B_C = R.from_euler('xyz', [0, 0, 30], degrees=True)
+    >>> tf_B_C = Tf.from_components(t_B_C, r_B_C)
+
+    In order to plot these frames from a consistent perspective, we need to
+    calculate the transform between A and C. Note that we do not make this
+    transform directly, but instead compose intermediate transforms that let us
+    get from C to A:
+
+    >>> tf_A_C = tf_A_B * tf_B_C  # A <- B <- C
+
+    Now we can plot these three frames from A's perspective.
+
+    >>> fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    >>> plot_transformed_axes(ax, tf_A, name="tfA")     # A plotted in A
+    >>> plot_transformed_axes(ax, tf_A_B, name="tfAB")  # B plotted in A
+    >>> plot_transformed_axes(ax, tf_A_C, name="tfAC")  # C plotted in A
+    >>> ax.set_title("A, B, C frames with respect to A")
+    >>> ax.set_aspect("equal")
+    >>> ax.figure.set_size_inches(6, 5)
+    >>> plt.show()
+
+    **Transforming Vectors**
+
+    Let's transform a vector from A, to B and C. To do this, we will first
+    invert the transforms we already have from B and C, to A.
+
+    >>> tf_B_A = tf_A_B.inv()  # B <- A
+    >>> tf_C_A = tf_A_C.inv()  # C <- A
+
+    Now we can define a point in A and use the above transforms to get its
+    coordinates in B and C:
+
+    >>> p1_A = np.array([1, 0, 0])  # +1 in x_A direction
+    >>> p1_B = tf_B_A.apply(p1_A)
+    >>> p1_C = tf_C_A.apply(p1_A)
+    >>> print(p1_A)  # Original point 1 in A
+    [1 0 0]
+    >>> print(p1_B)  # Point 1 in B
+    [3. 0. 0.]
+    >>> print(p1_C)  # Point 1 in C
+    [ 2.59807621 -1.5       -2.        ]
+
+    We can also do the reverse. We define a point in C and transform it to A:
+
+    >>> p2_C = np.array([0, 1, 0])  # +1 in y_C direction
+    >>> p2_A = tf_A_C.apply(p2_C)
+    >>> print(p2_C)  # Original point 2 in C
+    [0 1 0]
+    >>> print(p2_A)  # Point 2 in A
+    [-2.5       -2.         0.8660254]
+
+    Plot the frames with respect to A again, but also plot these two points:
+
+    >>> fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    >>> plot_transformed_axes(ax, tf_A, name="tfA")     # A plotted in A
+    >>> plot_transformed_axes(ax, tf_A_B, name="tfAB")  # B plotted in A
+    >>> plot_transformed_axes(ax, tf_A_C, name="tfAC")  # C plotted in A
+    >>> ax.scatter(p1_A[0], p1_A[1], p1_A[2], color=colors[0])  # +1 x_A
+    >>> ax.scatter(p2_A[0], p2_A[1], p2_A[2], color=colors[1])  # +1 y_C
+    >>> ax.set_title("A, B, C frames and points with respect to A")
+    >>> ax.set_aspect("equal")
+    >>> ax.figure.set_size_inches(6, 5)
+    >>> plt.show()
+
+    **Switching Base Frames**
+
+    Up to this point, we have been visualizing frames from A's perspective.
+    Let's use the transforms we defined to visualize the frames from C's
+    perspective.
+
+    Now C is the "base frame" or "world frame". All frames are the identity
+    transform from their own perspective.
+
+    >>> tf_C = Tf.identity()
+
+    We've already defined the transform C <- A, and can obtain C <- B by
+    inverting the existing transform B <- C.
+
+    >>> tf_C_B = tf_B_C.inv()  # C <- B
+
+    This lets us plot everything from C's perspective:
+
+    >>> fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    >>> plot_transformed_axes(ax, tf_C, name="tfC")     # C plotted in C
+    >>> plot_transformed_axes(ax, tf_C_B, name="tfCB")  # B plotted in C
+    >>> plot_transformed_axes(ax, tf_C_A, name="tfCA")  # A plotted in C
+    >>> ax.scatter(p1_C[0], p1_C[1], p1_C[2], color=colors[0])
+    >>> ax.scatter(p2_C[0], p2_C[1], p2_C[2], color=colors[1])
+    >>> ax.set_title("A, B, C frames and points with respect to C")
+    >>> ax.set_aspect("equal")
+    >>> ax.figure.set_size_inches(6, 5)
+    >>> plt.show()
+    """
+
+    # generic type compatibility with scipy-stubs
+    __class_getitem__: classmethod = classmethod(GenericAlias)
+
+    def __init__(self, matrix: ArrayLike, normalize: bool = True, copy: bool = True):
+        """Initialize from a 4x4 transformation matrix.
+
+        Rotations are not meant to be initialized directly. Please use one of
+        the `from_...` methods instead.
+
+        Parameters
+        ----------
+        matrix : array_like, shape (..., 4, 4)
+            A single transformation matrix or a stack of transformation
+            matrices.
+        normalize : bool, optional
+            If True, orthonormalize the rotation matrix using singular value
+            decomposition. If False, the rotation matrix is not checked for
+            orthogonality or right-handedness.
+        copy : bool, optional
+            If True, copy the input matrix. If False, a reference to the input
+            matrix is used. If normalize is True, the input matrix is always
+            copied regardless of the value of copy.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+        """
+        xp = array_namespace(matrix)
+        self._xp = xp
+        matrix = _promote(matrix, xp=xp)
+        if matrix.shape[-2:] != (4, 4):
+            raise ValueError(
+                f"Expected `matrix` to have shape (..., 4, 4), got {matrix.shape}."
+            )
+        # We only need the _single flag for the cython backend. The Array API backend
+        # uses broadcasting by default and hence returns the correct shape without
+        # additional _single logic
+        self._single = matrix.ndim == 2 and is_numpy(xp)
+        if self._single:
+            matrix = xpx.atleast_nd(matrix, ndim=3, xp=xp)
+
+        self._backend = select_backend(xp, matrix.ndim < 4)
+        self._matrix = self._backend.from_matrix(matrix, normalize, copy)
+
+    def __repr__(self):
+        m = f"{self.as_matrix()!r}".splitlines()
+        # bump indent (+27 characters)
+        m[1:] = [" " * 27 + m[i] for i in range(1, len(m))]
+        return "RigidTransform.from_matrix(" + "\n".join(m) + ")"
+
+    @staticmethod
+    def from_matrix(matrix: ArrayLike) -> RigidTransform:
+        """Initialize from a 4x4 transformation matrix.
+
+        Parameters
+        ----------
+        matrix : array_like, shape (..., 4, 4)
+            Transformation matrices. Each matrix[..., :, :] represents a 4x4
+            transformation matrix.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Object containing the rigid transform represented by the input matrix.
+
+        Notes
+        -----
+        4x4 rigid transformation matrices are of the form::
+
+            [       tx]
+            [   R   ty]
+            [       tz]
+            [ 0 0 0  1]
+
+        where ``R`` is a 3x3 rotation matrix and ``t = [tx, ty, tz]`` is a 3x1
+        translation vector. As rotation matrices must be proper orthogonal, the
+        rotation component is orthonormalized using singular value decomposition
+        before initialization.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        Creating a transform from a single matrix:
+
+        >>> m = np.array([[0, 1, 0, 2],
+        ...               [0, 0, 1, 3],
+        ...               [1, 0, 0, 4],
+        ...               [0, 0, 0, 1]])
+        >>> tf = Tf.from_matrix(m)
+        >>> tf.as_matrix()
+        array([[0., 1., 0., 2.],
+               [0., 0., 1., 3.],
+               [1., 0., 0., 4.],
+               [0., 0., 0., 1.]])
+        >>> tf.single
+        True
+
+        Creating a transform from an N-dimensional array of matrices:
+
+        >>> m = np.tile(np.eye(4), (2, 5, 1, 1))  # Shape (2, 5, 4, 4)
+        >>> tf = Tf.from_matrix(m)
+        >>> tf.shape
+        (2, 5)
+        >>> tf.single
+        False
+        >>> len(tf)
+        2
+
+        Matrices with a rotation component that is not proper orthogonal are
+        orthogonalized using singular value decomposition before initialization:
+
+        >>> tf = Tf.from_matrix(np.diag([2, 2, 2, 1]))
+        >>> tf.as_matrix()
+        array([[1., 0., 0., 0.],
+               [0., 1., 0., 0.],
+               [0., 0., 1., 0.],
+               [0., 0., 0., 1.]])
+        """
+        return RigidTransform(matrix, normalize=True, copy=True)
+
+    @staticmethod
+    def from_rotation(rotation: Rotation) -> RigidTransform:
+        """Initialize from a rotation, without a translation.
+
+        When applying this transform to a vector ``v``, the result is the
+        same as if the rotation was applied to the vector.
+        ``Tf.from_rotation(r).apply(v) == r.apply(v)``
+
+        Parameters
+        ----------
+        rotation : `Rotation` instance
+            A single rotation or a rotation with N leading dimensions.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Object containing the rigid transform represented by the input rotation.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        Creating a transform from a single rotation:
+
+        >>> r = R.from_euler("ZYX", [90, 30, 0], degrees=True)
+        >>> r.apply([1, 0, 0])
+        array([0.       , 0.8660254, -0.5     ])
+        >>> tf = Tf.from_rotation(r)
+        >>> tf.apply([1, 0, 0])
+        array([0.       , 0.8660254, -0.5     ])
+        >>> tf.single
+        True
+
+        The upper 3x3 submatrix of the transformation matrix is the rotation
+        matrix:
+
+        >>> np.allclose(tf.as_matrix()[:3, :3], r.as_matrix(), atol=1e-12)
+        True
+
+        Creating multiple transforms from a rotation with N leading dimensions:
+
+        >>> r = R.from_euler("ZYX", [[90, 30, 0], [45, 30, 60]], degrees=True)
+        >>> r.apply([1, 0, 0])
+        array([[0.        , 0.8660254 , -0.5       ],
+               [0.61237244, 0.61237244, -0.5       ]])
+        >>> tf = Tf.from_rotation(r)
+        >>> tf.apply([1, 0, 0])
+        array([[0.        , 0.8660254 , -0.5       ],
+               [0.61237244, 0.61237244, -0.5       ]])
+        >>> tf.single
+        False
+        >>> len(tf)
+        2
+        """
+        if not isinstance(rotation, Rotation):
+            raise TypeError(
+                "Expected `rotation` to be a `Rotation` instance, "
+                f"got {type(rotation)}."
+            )
+        quat = rotation.as_quat()
+        xp = array_namespace(quat)
+        backend = select_backend(xp, quat.ndim < 3)
+        matrix = backend.from_rotation(quat)
+        return RigidTransform._from_raw_matrix(matrix, xp, backend)
+
+    @staticmethod
+    def from_translation(translation: ArrayLike) -> RigidTransform:
+        """Initialize from a translation numpy array, without a rotation.
+
+        When applying this transform to a vector ``v``, the result is the same
+        as if the translation and vector were added together. If ``t`` is the
+        displacement vector of the translation, then:
+
+        ``Tf.from_translation(t).apply(v) == t + v``
+
+        Parameters
+        ----------
+        translation : array_like, shape (..., 3)
+            Translation vectors. Each translation[..., :] represents a 3D
+            translation vector.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Object containing the rigid transform represented by the input translation.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        Creating a transform from a single translation vector:
+
+        >>> t = np.array([2, 3, 4])
+        >>> t + np.array([1, 0, 0])
+        array([3, 3, 4])
+        >>> tf = Tf.from_translation(t)
+        >>> tf.apply([1, 0, 0])
+        array([3., 3., 4.])
+        >>> tf.single
+        True
+
+        The top 3x1 points in the rightmost column of the transformation matrix
+        is the translation vector:
+
+        >>> tf.as_matrix()
+        array([[1., 0., 0., 2.],
+               [0., 1., 0., 3.],
+               [0., 0., 1., 4.],
+               [0., 0., 0., 1.]])
+        >>> np.allclose(tf.as_matrix()[:3, 3], t)
+        True
+
+        Creating multiple transforms from an N-dimensional array of translation
+        vectors:
+
+        >>> t = np.array([[2, 3, 4], [1, 0, 0]])
+        >>> t + np.array([1, 0, 0])
+        array([[3, 3, 4],
+               [2, 0, 0]])
+        >>> tf = Tf.from_translation(t)
+        >>> tf.apply([1, 0, 0])
+        array([[3., 3., 4.],
+               [2., 0., 0.]])
+        >>> np.allclose(tf.as_matrix()[:, :3, 3], t)
+        True
+        >>> tf.single
+        False
+        >>> len(tf)
+        2
+        """
+        xp = array_namespace(translation)
+        translation = _promote(translation, xp=xp)
+        backend = select_backend(xp, translation.ndim < 3)
+        matrix = backend.from_translation(translation)
+        return RigidTransform._from_raw_matrix(matrix, xp, backend)
+
+    @staticmethod
+    def from_components(translation: ArrayLike, rotation: Rotation) -> RigidTransform:
+        """Initialize a rigid transform from translation and rotation
+        components.
+
+        When creating a rigid transform from a translation and rotation, the
+        translation is applied after the rotation, such that
+        ``tf = Tf.from_components(translation, rotation)``
+        is equivalent to
+        ``tf = Tf.from_translation(translation) * Tf.from_rotation(rotation)``.
+
+        When applying a transform to a vector ``v``, the result is the
+        same as if the transform was applied to the vector in the
+        following way: ``tf.apply(v) == translation + rotation.apply(v)``
+
+        Parameters
+        ----------
+        translation : array_like, shape (..., 3)
+            Translation vectors. Each translation[..., :] represents a 3D
+            translation vector.
+        rotation : `Rotation` instance
+            Rotation objects. The shape must be broadcastable with the
+            translation shape.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Rigid transform objects. The shape is determined by broadcasting
+            the translation and rotation shapes together.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        Creating from a single rotation and translation:
+
+        >>> t = np.array([2, 3, 4])
+        >>> r = R.from_euler("ZYX", [90, 30, 0], degrees=True)
+        >>> r.as_matrix()
+        array([[ 0.       , -1.,  0.        ],
+               [ 0.8660254,  0.,  0.5       ],
+               [-0.5      ,  0.,  0.8660254 ]])
+        >>> tf = Tf.from_components(t, r)
+        >>> tf.rotation.as_matrix()
+        array([[ 0.       , -1.,  0.        ],
+               [ 0.8660254,  0.,  0.5       ],
+               [-0.5      ,  0.,  0.8660254 ]])
+        >>> tf.translation
+        array([2., 3., 4.])
+        >>> tf.single
+        True
+
+        When applying a transform to a vector ``v``, the result is the same as
+        if the transform was applied to the vector in the following way:
+        ``tf.apply(v) == translation + rotation.apply(v)``
+
+        >>> r.apply([1, 0, 0])
+        array([0.       , 0.8660254, -0.5     ])
+        >>> t + r.apply([1, 0, 0])
+        array([2.       , 3.8660254,  3.5     ])
+        >>> tf.apply([1, 0, 0])
+        array([2.       , 3.8660254,  3.5     ])
+        """
+        rotation_tf = RigidTransform.from_rotation(rotation)
+        return RigidTransform.from_translation(translation) * rotation_tf
+
+    @staticmethod
+    def from_exp_coords(exp_coords: ArrayLike) -> RigidTransform:
+        r"""Initialize from exponential coordinates of transform.
+
+        This implements the exponential map that converts 6-dimensional real
+        vectors to SE(3).
+
+        An exponential coordinate vector consists of 6 elements
+        ``[rx, ry, rz, vx, vy, vz]``. The first 3 encode rotation (and form a
+        rotation vector used in `Rotation.from_rotvec`) and the last 3 encode
+        translation (and form a translation vector for pure translations).
+        The exponential mapping can be expressed as matrix exponential
+        ``T = exp(tau)``, where ``T`` is a 4x4 matrix representing a rigid
+        transform and ``tau`` is a 4x4 matrix formed from the elements of an
+        exponential coordinate vector::
+
+            tau = [  0 -rz  ry vx]
+                  [ rz   0 -rx vy]
+                  [-ry  rx   0 vz]
+                  [  0   0   0  1]
+
+        Parameters
+        ----------
+        exp_coords : array_like, shape (..., 6)
+            Exponential coordinate vectors. Each exp_coords[..., :] represents
+            a 6D exponential coordinate vector with the expected order of
+            components ``[rx, ry, rz, vx, vy, vz]``. The first 3 components
+            encode rotation and the last 3 encode translation.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Rigid transform objects with the same leading dimensions as the input.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        Creating from a single 6d vector of exponential coordinates:
+
+        >>> tf = Tf.from_exp_coords([
+        ...     -2.01041204, -0.52983629, 0.65773501,
+        ...     0.10386614, 0.05855009, 0.54959179])
+        >>> tf.as_matrix()
+        array([[0.76406621, 0.10504613, -0.63652819, -0.10209961],
+               [0.59956454, -0.47987325, 0.64050295, 0.40158789],
+               [-0.2381705, -0.87102639, -0.42963687, 0.19637636],
+               [0., 0., 0., 1.]])
+        >>> tf.single
+        True
+
+        A vector of zeros represents the identity transform:
+
+        >>> tf = Tf.from_exp_coords(np.zeros(6))
+        >>> tf.as_matrix()
+        array([[1., 0., 0., 0.],
+               [0., 1., 0., 0.],
+               [0., 0., 1., 0.],
+               [0., 0., 0., 1.]])
+
+        The last three numbers encode translation. If the first three numbers
+        are zero, the last three components can be interpreted as the
+        translation:
+
+        >>> tf_trans = Tf.from_exp_coords([0, 0, 0, 4.3, -2, 3.4])
+        >>> tf_trans.translation
+        array([4.3, -2., 3.4])
+
+        The first three numbers encode rotation as a rotation vector:
+
+        >>> tf_rot = Tf.from_exp_coords([0.5, 0.3, 0.1, 0, 0, 0])
+        >>> tf_rot.rotation.as_rotvec()
+        array([0.5, 0.3, 0.1])
+
+        Combining translation and rotation preserves the rotation vector,
+        but changes the last three components as they encode translation and
+        rotation:
+
+        >>> (tf_trans * tf_rot).as_exp_coords()
+        array([0.5, 0.3, 0.1, 3.64305882, -1.25879559, 4.46109265])
+        """
+        xp = array_namespace(exp_coords)
+        exp_coords = xp_promote(exp_coords, force_floating=True, xp=xp)
+        if exp_coords.shape[-1] != 6:
+            raise ValueError(
+                f"Expected `exp_coords` to have shape (..., 6), got {exp_coords.shape}."
+            )
+        backend = select_backend(xp, cython_compatible=exp_coords.ndim < 3)
+        matrix = backend.from_exp_coords(exp_coords)
+        return RigidTransform._from_raw_matrix(matrix, xp, backend)
+
+    @staticmethod
+    def from_dual_quat(
+        dual_quat: ArrayLike, *, scalar_first: bool = False
+    ) -> RigidTransform:
+        """Initialize from a unit dual quaternion.
+
+        Unit dual quaternions encode orientation in a real unit quaternion
+        and translation in a dual quaternion. There is a double cover, i.e.,
+        the unit dual quaternions q and -q represent the same transform.
+
+        Unit dual quaternions must have a real quaternion with unit norm and
+        a dual quaternion that is orthogonal to the real quaternion to satisfy
+        the unit norm constraint. This function will enforce both properties
+        through normalization.
+
+        Parameters
+        ----------
+        dual_quat : array_like, shape (..., 8)
+            Unit dual quaternions. Each dual_quat[..., :] represents a unit
+            dual quaternion. The real part is stored in the first four
+            components and the dual part in the last four components.
+        scalar_first : bool, optional
+            Whether the scalar component goes first or last in the two
+            individual quaternions that represent the real and the dual part.
+            Default is False, i.e. the scalar-last order is used.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Rigid transform objects with the same leading dimensions as the input.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        Creating from a single unit dual quaternion:
+
+        >>> tf = Tf.from_dual_quat([
+        ...     0.0617101, -0.06483886, 0.31432811, 0.94508498,
+        ...     0.04985168, -0.26119618, 0.1691491, -0.07743254])
+        >>> tf.as_matrix()
+        array([[0.79398752, -0.60213598, -0.08376202, 0.24605262],
+               [0.58613113, 0.79477941, -0.15740392, -0.4932833],
+               [0.16135089, 0.07588122, 0.98397557, 0.34262676],
+               [0., 0., 0., 1.]])
+        >>> tf.single
+        True
+        """
+        xp = array_namespace(dual_quat)
+        dual_quat = _promote(dual_quat, xp=xp)
+        backend = select_backend(xp, dual_quat.ndim < 3)
+        matrix = backend.from_dual_quat(dual_quat, scalar_first=scalar_first)
+        return RigidTransform._from_raw_matrix(matrix, xp, backend)
+
+    @staticmethod
+    def identity(
+        num: int | None = None, *, shape: int | tuple[int, ...] | None = None
+    ) -> RigidTransform:
+        """Initialize an identity transform.
+
+        Composition with the identity transform has no effect, and
+        applying the identity transform to a vector has no effect.
+
+        Parameters
+        ----------
+        num : int, optional
+            Number of identity transforms to generate. If None (default),
+            then a single transform is generated.
+        shape : int or tuple of ints, optional
+            Shape of the identity transforms. If specified, `num` must
+            be None.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            The identity transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        Creating a single identity transform:
+
+        >>> tf = Tf.identity()
+        >>> tf.as_matrix()
+        array([[1., 0., 0., 0.],
+               [0., 1., 0., 0.],
+               [0., 0., 1., 0.],
+               [0., 0., 0., 1.]])
+        >>> tf.single
+        True
+
+        The identity transform can be applied to a vector without effect:
+
+        >>> tf.apply([1, 2, 3])
+        array([1., 2., 3.])
+
+        The identity transform when composed with another transform has no
+        effect:
+
+        >>> rng = np.random.default_rng(123)
+        >>> t = rng.random(3)
+        >>> r = R.random(rng=rng)
+        >>> tf = Tf.from_components(t, r)
+        >>> np.allclose((Tf.identity() * tf).as_matrix(),
+        ...             tf.as_matrix(), atol=1e-12)
+        True
+
+        Multiple identity transforms can be generated at once:
+
+        >>> tf = Tf.identity(2)
+        >>> tf.as_matrix()
+        array([[[1., 0., 0., 0.],
+                [0., 1., 0., 0.],
+                [0., 0., 1., 0.],
+                [0., 0., 0., 1.]],
+               [[1., 0., 0., 0.],
+                [0., 1., 0., 0.],
+                [0., 0., 1., 0.],
+                [0., 0., 0., 1.]]])
+        >>> tf.single
+        False
+        >>> len(tf)
+        2
+        """
+        if num is not None and shape is not None:
+            raise ValueError("Only one of `num` and `shape` can be specified.")
+        if num is None and shape is None:
+            shape = ()
+        elif num is not None:
+            shape = (num,)
+        elif isinstance(shape, int):
+            shape = (shape,)
+        elif not isinstance(shape, tuple):
+            raise ValueError("`shape` must be an int or a tuple of ints or None.")
+        matrix = np.tile(np.eye(4), shape + (1, 1))
+        # No need for a backend call here since identity is easy to construct and we are
+        # currently not offering a backend-specific identity matrix
+        return RigidTransform._from_raw_matrix(matrix, array_namespace(matrix))
+
+    @staticmethod
+    def concatenate(
+        transforms: RigidTransform | Iterable[RigidTransform],
+    ) -> RigidTransform:
+        """
+        Concatenate a sequence of `RigidTransform` objects into a
+        single object.
+
+        Parameters
+        ----------
+        transforms : sequence of `RigidTransform`
+            If a single `RigidTransform` instance is passed in, a copy of
+            it is returned.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            The concatenated transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> tf1 = Tf.from_translation([1, 0, 0])
+        >>> tf2 = Tf.from_translation([[2, 0, 0], [3, 0, 0]])
+        >>> Tf.concatenate([tf1, tf2]).translation
+        array([[1., 0., 0.],
+               [2., 0., 0.],
+               [3., 0., 0.]])
+        """
+        if isinstance(transforms, RigidTransform):
+            return RigidTransform._from_raw_matrix(
+                transforms.as_matrix(), transforms._xp
+            )
+        if not all(isinstance(x, RigidTransform) for x in transforms):
+            raise TypeError("input must contain RigidTransform objects only")
+
+        xp = array_namespace(transforms[0].as_matrix())  # type:ignore[index]
+        matrix = xp.concat(
+            [xpx.atleast_nd(x.as_matrix(), ndim=3, xp=xp) for x in transforms]
+        )
+        return RigidTransform._from_raw_matrix(matrix, xp, None)
+
+    def mean(self,
+        weights: ArrayLike | None = None,
+        axis: None | int | tuple[int, ...] = None
+    ) -> RigidTransform:
+        """Get the mean of the transforms.
+
+        The mean of a set of transforms is the same as the mean of its
+        rotation and translation components.
+
+        The mean used for the rotation component is the chordal L2 mean (also
+        called the projected or induced arithmetic mean) [1]_. If ``A`` is a
+        set of rotation matrices, then the mean ``M`` is the rotation matrix
+        that minimizes the following loss function:
+
+        .. math::
+
+            L(M) = \\sum_{i = 1}^{n} w_i \\lVert \\mathbf{A}_i -
+            \\mathbf{M} \\rVert^2 ,
+
+        where :math:`w_i`'s are the `weights` corresponding to each matrix.
+
+        Parameters
+        ----------
+        weights : array_like shape (..., N), optional
+            Weights describing the relative importance of the transforms. If
+            None (default), then all values in `weights` are assumed to be
+            equal. If given, the shape of `weights` must be broadcastable to
+            the transform shape. Weights must be non-negative.
+        axis : None, int, or tuple of ints, optional
+            Axis or axes along which the means are computed. The default is to
+            compute the mean of all transforms.
+
+        Returns
+        -------
+        mean : `RigidTransform` instance
+            Single transform containing the mean of the transforms in the
+            current instance.
+
+        References
+        ----------
+        .. [1] Hartley, Richard, et al.,
+                "Rotation Averaging", International Journal of Computer Vision
+                103, 2013, pp. 267-305.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> rng = np.random.default_rng(seed=123)
+
+        The mean of a set of transforms is the same as the mean of the
+        translation and rotation components:
+
+        >>> t = rng.random((4, 3))
+        >>> r = R.random(4, rng=rng)
+        >>> tf = Tf.from_components(t, r)
+        >>> tf.mean().as_matrix()
+        array([[ 0.61593485, -0.74508342,  0.25588075,  0.66999034],
+               [-0.59353615, -0.65246765, -0.47116962,  0.25481794],
+               [ 0.51801458,  0.13833531, -0.84411151,  0.52429339],
+               [0., 0., 0., 1.]])
+        >>> Tf.from_components(t.mean(axis=0), r.mean()).as_matrix()
+        array([[ 0.61593485, -0.74508342,  0.25588075,  0.66999034],
+               [-0.59353615, -0.65246765, -0.47116962,  0.25481794],
+               [ 0.51801458,  0.13833531, -0.84411151,  0.52429339],
+               [0., 0., 0., 1.]])
+        """
+        mean = self._backend.mean(self._matrix, weights=weights, axis=axis)
+        return RigidTransform._from_raw_matrix(mean, xp=self._xp,
+                                               backend=self._backend)
+
+    def as_matrix(self) -> Array:
+        """Return a copy of the matrix representation of the transform.
+
+        4x4 rigid transformation matrices are of the form::
+
+            [       tx]
+            [   R   ty]
+            [       tz]
+            [ 0 0 0  1]
+
+        where ``R`` is a 3x3 orthonormal rotation matrix and
+        ``t = [tx, ty, tz]`` is a 3x1 translation vector.
+
+        Returns
+        -------
+        matrix : numpy.ndarray, shape (..., 4, 4)
+            Transformation matrices with the same leading dimensions as the transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        A transformation matrix is a 4x4 matrix formed from a 3x3 rotation
+        matrix and a 3x1 translation vector:
+
+        >>> t = np.array([2, 3, 4])
+        >>> r = R.from_matrix([[0, 0, 1],
+        ...                    [1, 0, 0],
+        ...                    [0, 1, 0]])
+        >>> tf = Tf.from_components(t, r)
+        >>> tf.as_matrix()
+        array([[ 0., 0., 1., 2.],
+               [ 1., 0., 0., 3.],
+               [ 0., 1., 0., 4.],
+               [ 0., 0., 0., 1.]])
+
+        >>> Tf.identity(2).as_matrix()
+        array([[[1., 0., 0., 0.],
+                [0., 1., 0., 0.],
+                [0., 0., 1., 0.],
+                [0., 0., 0., 1.]],
+               [[1., 0., 0., 0.],
+                [0., 1., 0., 0.],
+                [0., 0., 1., 0.],
+                [0., 0., 0., 1.]]])
+        """
+        matrix = self._xp.asarray(self._matrix, copy=True)
+        if self._single:
+            return matrix[0, ...]
+        return matrix
+
+    def as_components(self) -> tuple[Array, Rotation]:
+        """Return the translation and rotation components of the transform,
+        where the rotation is applied first, followed by the translation.
+
+        4x4 rigid transformation matrices are of the form::
+
+            [       tx]
+            [   R   ty]
+            [       tz]
+            [ 0 0 0  1]
+
+        Where ``R`` is a 3x3 orthonormal rotation matrix and
+        ``t = [tx, ty, tz]`` is a 3x1 translation vector. This function
+        returns the rotation corresponding to this rotation matrix
+        ``r = Rotation.from_matrix(R)`` and the translation vector ``t``.
+
+        When applying a transform ``tf`` to a vector ``v``, the result is the same
+        as if the rotation and translation components were applied to the vector
+        with the following operation:
+        ``tf.apply(v) == translation + rotation.apply(v)``.
+
+        Returns
+        -------
+        translation : numpy.ndarray, shape (..., 3)
+            The translation of the transform.
+        rotation : `Rotation` instance
+            The rotation of the transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        Recover the rotation and translation from a transform:
+
+        >>> t = np.array([2, 3, 4])
+        >>> r = R.from_matrix([[0, 0, 1],
+        ...                    [1, 0, 0],
+        ...                    [0, 1, 0]])
+        >>> tf = Tf.from_components(t, r)
+        >>> t, r = tf.as_components()
+        >>> t
+        array([2., 3., 4.])
+        >>> r.as_matrix()
+        array([[0., 0., 1.],
+               [1., 0., 0.],
+               [0., 1., 0.]])
+
+        The transform applied to a vector is equivalent to the rotation applied
+        to the vector, followed by the translation:
+
+        >>> t + r.apply([1, 0, 0])
+        array([2., 4., 4.])
+        >>> tf.apply([1, 0, 0])
+        array([2., 4., 4.])
+        """
+        return self.translation, self.rotation
+
+    def as_exp_coords(self) -> Array:
+        """Return the exponential coordinates of the transform.
+
+        This implements the logarithmic map that converts SE(3) to 6-dimensional
+        real vectors.
+
+        This is an inverse of `from_exp_coords` where details on the mapping can
+        be found.
+
+        Returns
+        -------
+        exp_coords : numpy.ndarray, shape (..., 6)
+            Exponential coordinate vectors with the same leading dimensions as the
+            transform. The first three components define the rotation and the last
+            three components define the translation.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        Get exponential coordinates of the identity matrix:
+
+        >>> Tf.identity().as_exp_coords()
+        array([0., 0., 0., 0., 0., 0.])
+        """
+        exp_coords = self._backend.as_exp_coords(self._matrix)
+        if self._single:
+            exp_coords = exp_coords[0, ...]
+        return exp_coords
+
+    def as_dual_quat(self, *, scalar_first: bool = False) -> Array:
+        """Return the dual quaternion representation of the transform.
+
+        Unit dual quaternions encode orientation in a real unit quaternion
+        and translation in a dual quaternion. There is a double cover, i.e.,
+        the unit dual quaternions q and -q represent the same transform.
+
+        Parameters
+        ----------
+        scalar_first : bool, optional
+            Whether the scalar component goes first or last in the two
+            individual quaternions that represent the real and the dual part.
+            Default is False, i.e. the scalar-last order is used.
+
+        Returns
+        -------
+        dual_quat : numpy.ndarray, shape (..., 8)
+            Unit dual quaternion vectors with the same leading dimensions as the
+            transform. The real part is stored in the first four components and the
+            dual part in the last four components.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        Get identity dual quaternion (we use scalar-last by default):
+
+        >>> Tf.identity().as_dual_quat()
+        array([0., 0., 0., 1., 0., 0., 0., 0.])
+
+        When we want to use the scalar-first convention, we use the argument:
+
+        >>> Tf.identity().as_dual_quat(scalar_first=True)
+        array([1., 0., 0., 0., 0., 0., 0., 0.])
+        """
+        dual_quat = self._backend.as_dual_quat(self._matrix, scalar_first=scalar_first)
+        if self._single:
+            dual_quat = dual_quat[0]
+        return dual_quat
+
+    def __len__(self) -> int:
+        """Return the length of the leading transform dimension.
+
+        A transform can store an N-dimensional array of transforms. The length is the
+        size of the first dimension of this array. If the transform is a single
+        transform, the length is not defined and an error is raised.
+
+        Returns
+        -------
+        length : int
+            The number of transforms in this object.
+
+        Raises
+        ------
+        TypeError
+            If the transform is a single transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+        >>> tf = Tf.identity(3)
+        >>> len(tf)
+        3
+
+        An N-dimensional array of transforms returns its first dimension size:
+
+        >>> t = np.ones((5, 2, 3, 1, 3))
+        >>> tf = Tf.from_translation(t)
+        >>> len(tf)
+        5
+
+        A single transform has no length:
+
+        >>> tf = Tf.from_translation([1, 0, 0])
+        >>> len(tf)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        TypeError: Single transform has no len().
+        """
+        # We don't use self._single here because we also want to raise an error for
+        # Array API backends that call len() on single RigidTransform objects.
+        if self.single:
+            raise TypeError("Single transform has no len")
+        return self._matrix.shape[0]
+
+    def __getitem__(
+        self, indexer: int | slice | EllipsisType | None | ArrayLike
+    ) -> RigidTransform:
+        """Extract transform(s) at given index(es) from this object.
+
+        Creates a new `RigidTransform` instance containing a subset of
+        transforms stored in this object.
+
+        Parameters
+        ----------
+        indexer : int or slice or array_like
+            Specifies which transform(s) to extract. A single indexer must be
+            specified, i.e. as if indexing a 1 dimensional array or list.
+
+        Returns
+        -------
+        transform : `RigidTransform` instance
+            Contains
+                - a single transform, if `indexer` is a single index
+                - a stack of transform(s), if `indexer` is a slice, or an index
+                  array.
+
+        Raises
+        ------
+        TypeError
+            If the transform is a single transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> t = [[0, 0, 0], [1, 0, 0], [2, 0, 0]]  # 3 translations
+        >>> tf = Tf.from_translation(t)
+
+        A single index returns a single transform:
+
+        >>> tf[0].as_matrix()
+        array([[1., 0., 0., 0.],
+               [0., 1., 0., 0.],
+               [0., 0., 1., 0.],
+               [0., 0., 0., 1.]])
+
+        A slice returns a stack of transforms:
+
+        >>> tf[1:3].translation
+        array([[1., 0., 0.],
+               [2., 0., 0.]])
+
+        An index array returns a stack of transforms:
+
+        >>> tf[[0, 2]].translation
+        array([[0., 0., 0.],
+               [2., 0., 0.]])
+        """
+        if self.single:
+            raise TypeError("Single transform is not subscriptable.")
+
+        is_array = isinstance(indexer, type(self._matrix))
+        xp = self._xp
+        # Masking is only specified in the Array API when the array is the sole index
+        # This special case handling is necessary to support boolean indexing and
+        # integer array indexing with take (see
+        # https://github.com/data-apis/array-api/pull/900#issuecomment-2674432480)
+        # Ideally we would converge to [indexer, ...] indexing, but this is not
+        # supported for now.
+        if is_array and indexer.dtype == xp.bool:  # type:ignore[union-attr]
+            return RigidTransform(self._matrix[indexer], normalize=False)
+        if is_array and xp.isdtype(indexer.dtype, "integral"):  # type:ignore[union-attr]
+            if self._matrix.shape[0] == 0:
+                raise IndexError("cannot take from an empty array")
+            return RigidTransform(
+                xp.take(self._matrix, indexer, axis=0), normalize=False
+            )
+        return RigidTransform(self._matrix[indexer, ...], normalize=False)
+
+    def __setitem__(
+        self,
+        indexer: int | slice | EllipsisType | None | ArrayLike,
+        value: RigidTransform,
+    ):
+        """Set transform(s) at given index(es) in this object.
+
+        Parameters
+        ----------
+        indexer : int or slice or array_like
+            Specifies which transform(s) to replace. A single indexer must be
+            specified, i.e. as if indexing a 1 dimensional array or list.
+
+        value : `RigidTransform` instance
+            The transform(s) to set.
+
+        Raises
+        ------
+        TypeError
+            If the transform is a single transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> t = [[0, 0, 0], [1, 0, 0], [2, 0, 0]]  # 3 translations
+        >>> tf = Tf.from_translation(t)
+
+        Set a single transform:
+
+        >>> tf[0] = Tf.from_translation([9, 9, 9])
+        >>> tf.translation
+        array([[9., 9., 9.],
+               [1., 0., 0.],
+               [2., 0., 0.]])
+        """
+        if self.single:
+            raise TypeError("Single transform is not subscriptable.")
+
+        if not isinstance(value, RigidTransform):
+            raise TypeError("value must be a RigidTransform object")
+
+        self._matrix = self._backend.setitem(self._matrix, indexer, value.as_matrix())
+
+    def __mul__(
+        self, other: RigidTransform | Rotation
+    ) -> RigidTransform | NotImplementedType:
+        """Compose this transform with the other.
+
+        If ``p`` and ``q`` are two transforms, then the composition of '``q``
+        followed by ``p``' is equivalent to ``p * q``. In terms of
+        transformation matrices, the composition can be expressed as
+        ``p.as_matrix() @ q.as_matrix()``.
+
+        In terms of translations and rotations, the composition when applied to
+        a vector ``v`` is equivalent to
+        ``p.translation + p.rotation.apply(q.translation)
+        + (p.rotation * q.rotation).apply(v)``.
+
+        This function supports composition of multiple transforms at a time using
+        broadcasting rules. The resulting shape for two `RigidTransform` instances
+        ``p`` and ``q`` is `np.broadcast_shapes(p.shape, q.shape)`.
+
+        If ``other`` is a `Rotation`, it is automatically promoted to a
+        `RigidTransform` with zero translation.
+
+        Parameters
+        ----------
+        other : `RigidTransform` or `Rotation` instance
+            Transform(s) or rotation(s) to be composed with this one. The shapes
+            must be broadcastable.
+
+        Returns
+        -------
+        `RigidTransform` instance
+            The composed transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        Compose two transforms:
+
+        >>> tf1 = Tf.from_translation([1, 0, 0])
+        >>> tf2 = Tf.from_translation([0, 1, 0])
+        >>> tf = tf1 * tf2
+        >>> tf.translation
+        array([1., 1., 0.])
+        >>> tf.single
+        True
+
+        When applied to a vector, the composition of two transforms is applied
+        in right-to-left order.
+
+        >>> t1, r1 = [1, 2, 3], R.from_euler('z', 60, degrees=True)
+        >>> t2, r2 = [0, 1, 0], R.from_euler('x', 30, degrees=True)
+        >>> tf1 = Tf.from_components(t1, r1)
+        >>> tf2 = Tf.from_components(t2, r2)
+        >>> tf = tf1 * tf2
+        >>> tf.apply([1, 0, 0])
+        array([0.6339746, 3.3660254, 3.       ])
+        >>> tf1.apply(tf2.apply([1, 0, 0]))
+        array([0.6339746, 3.3660254, 3.       ])
+
+        When at least one of the transforms is not single, the result is a stack
+        of transforms.
+
+        >>> tf1 = Tf.from_translation([1, 0, 0])
+        >>> tf2 = Tf.from_translation([[0, 2, 0], [0, 0, 3]])
+        >>> tf = tf1 * tf2
+        >>> tf.translation
+        array([[1., 2., 0.],
+               [1., 0., 3.]])
+        >>> tf.single
+        False
+        >>> len(tf)
+        2
+
+        Broadcasting rules apply when composing multiple transforms at a time.
+
+        >>> tf1 = Tf.from_translation(np.ones((5, 1, 3)))  # Shape (5, 1, 3)
+        >>> tf2 = Tf.from_translation(np.ones((1, 4, 3)))  # Shape (1, 4, 3)
+        >>> tf = tf1 * tf2  # Shape (5, 4, 3)
+        >>> tf.translation.shape
+        (5, 4, 3)
+        """
+        if isinstance(other, Rotation):
+            other = RigidTransform.from_rotation(other)
+        elif not isinstance(other, RigidTransform):
+            # If other is not a RigidTransform, we return NotImplemented to allow other
+            # types to implement __rmul__
+            return NotImplemented
+        if not broadcastable(self._matrix.shape, other._matrix.shape):
+            raise ValueError(
+                f"Cannot broadcast {self._matrix.shape[:-2]} transforms in "
+                f"first to {other._matrix.shape[:-2]} transforms in second object."
+            )
+        cython_compatible = self._matrix.ndim < 4 and other._matrix.ndim < 4
+        backend = select_backend(self._xp, cython_compatible=cython_compatible)
+        matrix = backend.compose_transforms(self._matrix, other._matrix)
+        # Only necessary for cython. Array API broadcasting handles this by default
+        if self._single and other._single:
+            matrix = matrix[0, ...]
+        return RigidTransform(matrix, normalize=True, copy=False)
+
+    def __rmul__(self, other: Rotation) -> RigidTransform | NotImplementedType:
+        """Compose a rotation with this transform (rotation applied second).
+
+        See `__mul__` for more details.
+
+        Parameters
+        ----------
+        other : `Rotation` instance
+            The rotation to compose with this transform. The shapes must be
+            broadcastable.
+
+        Returns
+        -------
+        `RigidTransform` instance
+            The composed transform.
+        """
+        if isinstance(other, Rotation):
+            return RigidTransform.from_rotation(other) * self
+        # When other is a RigidTransform __mul__ is called, so we don't handle it here
+        return NotImplemented
+
+    def __pow__(self, n: float) -> RigidTransform:
+        """Compose this transform with itself `n` times.
+
+        A rigid transform `p` when raised to non-integer powers can be thought
+        of as finding a fraction of the transformation. For example, a power of
+        0.5 finds a "halfway" transform from the identity to `p`.
+
+        This is implemented by applying screw linear interpolation (ScLERP)
+        between `p` and the identity transform, where the angle of the rotation
+        component is scaled by `n`, and the translation is proportionally
+        adjusted along the screw axis.
+
+        ``q = p ** n`` can also be expressed as
+        ``q = RigidTransform.from_exp_coords(p.as_exp_coords() * n)``.
+
+        If `n` is negative, then the transform is inverted before the power
+        is applied. In other words, ``p ** -abs(n) == p.inv() ** abs(n)``.
+
+        Parameters
+        ----------
+        n : float
+            The number of times to compose the transform with itself.
+
+        Returns
+        -------
+        `RigidTransform` instance
+            If the input Rotation `p` contains `N` multiple rotations, then
+            the output will contain `N` rotations where the `i` th rotation
+            is equal to ``p[i] ** n``.
+
+        Notes
+        -----
+        There are three notable cases: if ``n == 1`` then a copy of the original
+        transform is returned, if ``n == 0`` then the identity transform is
+        returned, and if ``n == -1`` then the inverse transform is returned.
+
+        Note that fractional powers ``n`` which effectively take a root of
+        rotation, do so using the shortest path smallest representation of that
+        angle (the principal root). This means that powers of ``n`` and ``1/n``
+        are not necessarily inverses of each other. For example, a 0.5 power of
+        a +240 degree rotation will be calculated as the 0.5 power of a -120
+        degree rotation, with the result being a rotation of -60 rather than
+        +120 degrees.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> import numpy as np
+
+        A power of 2 returns the transform composed with itself:
+
+        >>> tf = Tf.from_translation([1, 2, 3])
+        >>> (tf ** 2).translation
+        array([2., 4., 6.])
+        >>> (tf ** 2).as_matrix()
+        array([[1., 0., 0., 2.],
+               [0., 1., 0., 4.],
+               [0., 0., 1., 6.],
+               [0., 0., 0., 1.]])
+
+        A negative power returns the inverse of the transform raised to the
+        absolute value of `n`:
+
+        >>> (tf ** -2).translation
+        array([-2., -4., -6.])
+        >>> np.allclose((tf ** -2).as_matrix(), (tf.inv() ** 2).as_matrix(),
+        ...             atol=1e-12)
+        True
+
+        A power of 0 returns the identity transform:
+
+        >>> (tf ** 0).as_matrix()
+        array([[1., 0., 0., 0.],
+               [0., 1., 0., 0.],
+               [0., 0., 1., 0.],
+               [0., 0., 0., 1.]])
+
+        A power of 1 returns a copy of the original transform:
+
+        >>> (tf ** 1).as_matrix()
+        array([[1., 0., 0., 1.],
+               [0., 1., 0., 2.],
+               [0., 0., 1., 3.],
+               [0., 0., 0., 1.]])
+
+        A fractional power returns a transform with a scaled rotation and
+        translated along the screw axis. Here we take the square root of the
+        transform, which when squared recovers the original transform:
+
+        >>> tf_half = (tf ** 0.5)
+        >>> tf_half.translation
+        array([0.5, 1., 1.5])
+        >>> (tf_half ** 2).as_matrix()
+        array([[1., 0., 0., 1.],
+               [0., 1., 0., 2.],
+               [0., 0., 1., 3.],
+               [0., 0., 0., 1.]])
+        """
+        matrix = self._backend.pow(self._matrix, n)
+        if self._single:
+            matrix = matrix[0, ...]
+        return RigidTransform._from_raw_matrix(matrix, self._xp, self._backend)
+
+    def inv(self) -> RigidTransform:
+        """Invert this transform.
+
+        Composition of a transform with its inverse results in an identity
+        transform.
+
+        A rigid transform is a composition of a rotation and a translation,
+        where the rotation is applied first, followed by the translation. So the
+        inverse transform is equivalent to the inverse translation followed by
+        the inverse rotation.
+
+        Returns
+        -------
+        `RigidTransform` instance
+            The inverse of this transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        A transform composed with its inverse results in an identity transform:
+
+        >>> rng = np.random.default_rng(seed=123)
+        >>> t = rng.random(3)
+        >>> r = R.random(rng=rng)
+        >>> tf = Tf.from_components(t, r)
+        >>> tf.as_matrix()
+        array([[-0.45431291,  0.67276178, -0.58394466,  0.68235186],
+               [-0.23272031,  0.54310598,  0.80676958,  0.05382102],
+               [ 0.85990758,  0.50242162, -0.09017473,  0.22035987],
+               [ 0.        ,  0.        ,  0.        ,  1.        ]])
+
+        >>> (tf.inv() * tf).as_matrix()
+        array([[[1., 0., 0., 0.],
+                [0., 1., 0., 0.],
+                [0., 0., 1., 0.],
+                [0., 0., 0., 1.]]])
+
+        The inverse rigid transform is the same as the inverse translation
+        followed by the inverse rotation:
+
+        >>> t, r = tf.as_components()
+        >>> r_inv = r.inv()  # inverse rotation
+        >>> t_inv = -t  # inverse translation
+        >>> tf_r_inv = Tf.from_rotation(r_inv)
+        >>> tf_t_inv = Tf.from_translation(t_inv)
+        >>> np.allclose((tf_r_inv * tf_t_inv).as_matrix(),
+        ...             tf.inv().as_matrix(),
+        ...             atol=1e-12)
+        True
+        >>> (tf_r_inv * tf_t_inv * tf).as_matrix()
+        array([[[1., 0., 0., 0.],
+                [0., 1., 0., 0.],
+                [0., 0., 1., 0.],
+                [0., 0., 0., 1.]]])
+        """
+        matrix = self._backend.inv(self._matrix)
+        if self._single:
+            matrix = matrix[0, ...]
+        return RigidTransform._from_raw_matrix(matrix, self._xp, self._backend)
+
+    def apply(self, vector: ArrayLike, inverse: bool = False) -> Array:
+        """Apply the transform to a vector.
+
+        If the original frame transforms to the final frame by this transform,
+        then its application to a vector can be seen in two ways:
+
+            - As a projection of vector components expressed in the final frame
+              to the original frame.
+            - As the physical transformation of a vector being glued to the
+              original frame as it transforms. In this case the vector
+              components are expressed in the original frame before and after
+              the transformation.
+
+        In terms of the rotation matrix and translation,
+        this application is the same as
+        ``self.translation + (mat @ vector[..., np.newaxis])[..., 0]``,
+        where ``mat = self.rotation.as_matrix()``.
+
+        For a single transform, this is the same as
+        ``self.translation + vector @ self.rotation.as_matrix().T``.
+
+        Parameters
+        ----------
+        vector : array_like, shape (..., 3)
+            Vector(s) to be transformed. Each vector[..., :] represents a 3D
+            vector.
+        inverse : bool, optional
+            If True, the inverse of the transform is applied to the vector.
+
+        Returns
+        -------
+        transformed_vector : numpy.ndarray, shape (..., 3)
+            The transformed vector(s) with shape determined by broadcasting
+            the transform and vector shapes together.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        Apply a single transform to a vector. Here the transform is just a
+        translation, so the result is the vector added to the translation
+        vector.
+
+        >>> t = np.array([1, 2, 3])
+        >>> tf = Tf.from_translation(t)
+        >>> t + np.array([1, 0, 0])
+        array([2, 2, 3])
+        >>> tf.apply([1, 0, 0])
+        array([2., 2., 3.])
+
+        Apply a single transform to a stack of vectors:
+
+        >>> tf.apply([[1, 0, 0], [0, 1, 0]])
+        array([[2., 2., 3.],
+               [1., 3., 3.]])
+
+        Apply the inverse of a transform to a vector, so the result is the
+        negative of the translation vector added to the vector.
+
+        >>> -t + np.array([1, 0, 0])
+        array([0, -2, -3])
+        >>> tf.apply([1, 0, 0], inverse=True)
+        array([0., -2., -3.])
+
+        Broadcasting is supported when applying multiple transforms to an N-dimensional
+        array of vectors.
+
+        >>> tf = Tf.from_translation(np.ones((4, 5, 1, 3)))
+        >>> vectors = np.zeros((2, 3))
+        >>> tf.apply(vectors).shape
+        (4, 5, 2, 3)
+
+        For transforms which are not just pure translations, applying it to a
+        vector is the same as applying the rotation component to the vector and
+        then adding the translation component.
+
+        >>> r = R.from_euler('z', 60, degrees=True)
+        >>> tf = Tf.from_components(t, r)
+        >>> t + r.apply([1, 0, 0])
+        array([1.5,       2.8660254, 3.       ])
+        >>> tf.apply([1, 0, 0])
+        array([1.5,       2.8660254, 3.       ])
+
+        When applying the inverse of a transform, the result is the negative of
+        the translation vector added to the vector, and then rotated by the
+        inverse rotation.
+
+        >>> r.inv().apply(-t + np.array([1, 0, 0]))
+        array([-1.73205081, -1.        , -3.        ])
+        >>> tf.apply([1, 0, 0], inverse=True)
+        array([-1.73205081, -1.        , -3.        ])
+        """
+        # We do not use the cached xp here to catch cases where matrix and vector have
+        # different xp instances.
+        xp = array_namespace(self._matrix, vector)
+        vector = xp.asarray(
+            vector, dtype=self._matrix.dtype, device=device(self._matrix)
+        )
+        cython_compatible = self._matrix.ndim < 4 and vector.ndim < 3
+        backend = select_backend(xp, cython_compatible=cython_compatible)
+        result = backend.apply(self._matrix, vector, inverse)
+        if self._single and vector.ndim == 1:
+            result = result[0, ...]
+        return result
+
+    @property
+    def rotation(self) -> Rotation:
+        """Return the rotation component of the transform.
+
+        A transform is a composition of a rotation and a translation, such that
+        when applied to a vector, the vector is first rotated and then
+        translated. This property returns the rotation part of the transform.
+
+        Returns
+        -------
+        rotation : `Rotation` instance
+            A single rotation or a stack of rotations.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        The rotation component is extracted from the transform:
+
+        >>> t = np.array([1, 0, 0])
+        >>> r = R.random(3)
+        >>> tf = Tf.from_components(t, r)
+        >>> np.allclose(tf.rotation.as_matrix(), r.as_matrix())
+        True
+        """
+        if self._single:
+            return Rotation.from_matrix(self._matrix[0, :3, :3])
+        return Rotation.from_matrix(self._matrix[..., :3, :3])
+
+    @property
+    def translation(self) -> Array:
+        """Return the translation component of the transform.
+
+        A transform is a composition of a rotation and a translation, such that
+        when applied to a vector, the vector is first rotated and then
+        translated. This property returns the translation part of the transform.
+
+        Returns
+        -------
+        translation : numpy.ndarray, shape (..., 3)
+            Translation vectors with the same leading dimensions as the transform.
+
+        Examples
+        --------
+        >>> from scipy.spatial.transform import RigidTransform as Tf
+        >>> from scipy.spatial.transform import Rotation as R
+        >>> import numpy as np
+
+        The translation component is extracted from the transform:
+
+        >>> t = np.array([[1, 0, 0], [2, 0, 0], [3, 0, 0]])
+        >>> r = R.random()
+        >>> tf = Tf.from_components(t, r)
+        >>> np.allclose(tf.translation, t)
+        True
+        """
+        if self._single:
+            return self._xp.asarray(self._matrix[0, :3, 3], copy=True)
+        return self._xp.asarray(self._matrix[..., :3, 3], copy=True)
+
+    @property
+    def single(self) -> bool:
+        """Whether this instance represents a single transform.
+
+        Single transforms are not subscriptable, and do not have a length.
+
+        Returns
+        -------
+        single : bool
+            True if this instance represents a single transform, False
+            otherwise.
+        """
+        return self._single or self._matrix.ndim == 2
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        """The shape of the transform's leading dimensions."""
+        if self._single or self._matrix.ndim == 2:
+            return ()
+        return self._matrix.shape[:-2]
+
+    def __reduce__(self) -> tuple[Callable, tuple]:
+        """Reduce the RigidTransform for pickling.
+
+        We store modules inside RigidTransforms which cannot be pickled. To circumvent
+        this, we pickle only the matrix and restore the cached modules from the matrix
+        type in `from_matrix`.
+        """
+        matrix = self._matrix
+        if self._single:
+            matrix = matrix[0, ...]
+        return (self.__class__.from_matrix, (matrix,))
+
+    def __iter__(self) -> Iterator[RigidTransform]:
+        """Iterate over transforms."""
+        if self._single or self._matrix.ndim == 2:
+            raise TypeError("Single transform is not iterable.")
+        # We return a generator that yields a new RigidTransform object for each
+        # transform in the current object. We cannot rely on the default implementation
+        # because jax will not raise an IndexError for out-of-bounds indices.
+        for i in range(self._matrix.shape[0]):
+            yield RigidTransform._from_raw_matrix(
+                self._matrix[i, ...], self._xp, self._backend
+            )
+
+    @staticmethod
+    def _from_raw_matrix(
+        matrix: Array, xp: ModuleType, backend: ModuleType | None = None
+    ) -> RigidTransform:
+        """Create a RigidTransform skipping all sanitization steps.
+
+        This method is is intended for internal, performant creation of RigidTransforms
+        with matrices that are guaranteed to be valid.
+        """
+        tf = RigidTransform.__new__(RigidTransform)
+        tf._single = matrix.ndim == 2 and is_numpy(xp)
+        if tf._single:
+            matrix = xpx.atleast_nd(matrix, ndim=3, xp=xp)
+        tf._matrix = matrix
+        tf._xp = xp
+        if backend is None:
+            backend = select_backend(xp, matrix.ndim < 4)
+        tf._backend = backend
+        return tf

v12x/pylib/scipy/spatial/transform/_rigid_transform_xp.py

@@ -0,0 +1,448 @@
+from types import EllipsisType
+
+from scipy._lib._array_api import (
+    array_namespace,
+    Array,
+    ArrayLike,
+    is_lazy_array,
+    xp_vector_norm,
+    xp_result_type,
+    xp_promote,
+    is_array_api_obj,
+)
+import scipy._external.array_api_extra as xpx
+from scipy.spatial.transform._rotation_xp import (
+    as_matrix as quat_as_matrix,
+    from_matrix as quat_from_matrix,
+    _from_matrix_orthogonal as quat_from_matrix_orthogonal,
+    from_rotvec as quat_from_rotvec,
+    as_rotvec as quat_as_rotvec,
+    compose_quat,
+    from_quat,
+    inv as quat_inv,
+    mean as quat_mean,
+)
+from scipy._external.array_api_compat import device as xp_device
+from scipy._lib._util import broadcastable
+
+
+def from_matrix(matrix: Array, normalize: bool = True, copy: bool = True) -> Array:
+    xp = array_namespace(matrix)
+    # Shape check should be done before calling this function
+    if normalize or copy:
+        matrix = xp.asarray(matrix, copy=True)
+
+    last_row_ok = xp.all(
+        matrix[..., 3, :] == xp.asarray([0, 0, 0, 1.0], device=xp_device(matrix)),
+        axis=-1,
+    )
+    lazy = is_lazy_array(matrix)
+    # We delay lazy branch checks until after normalization to avoid overwriting nans
+    # with the rotation matrix
+    if not lazy and xp.any(~last_row_ok):
+        if last_row_ok.shape == ():
+            idx = ()
+        else:
+            idx = tuple(int(i[0]) for i in xp.nonzero(~last_row_ok))
+        vals = matrix[idx + (3, ...)]
+        raise ValueError(
+            f"Expected last row of transformation matrix {idx} to be "
+            f"exactly [0, 0, 0, 1], got {vals}"
+        )
+
+    # The quat_from_matrix() method orthogonalizes the rotation
+    # component of the transformation matrix. While this does have some
+    # overhead in converting a rotation matrix to a quaternion and back, it
+    # allows for skipping singular value decomposition for near-orthogonal
+    # matrices, which is a computationally expensive operation.
+    if normalize:
+        rotmat = quat_as_matrix(quat_from_matrix(matrix[..., :3, :3]))
+        matrix = xpx.at(matrix)[..., :3, :3].set(rotmat)
+    # Lazy branch matrix invalidation
+    if lazy:
+        matrix = xp.where(last_row_ok[..., None, None], matrix, xp.nan)
+    return matrix
+
+
+def from_rotation(quat: Array) -> Array:
+    xp = array_namespace(quat)
+    rotmat = quat_as_matrix(quat)
+    matrix = xp.zeros(
+        (*rotmat.shape[:-2], 4, 4), dtype=quat.dtype, device=xp_device(quat)
+    )
+    matrix = xpx.at(matrix)[..., :3, :3].set(rotmat)
+    matrix = xpx.at(matrix)[..., 3, 3].set(1)
+    return matrix
+
+
+def from_translation(translation: Array) -> Array:
+    xp = array_namespace(translation)
+
+    if translation.shape[-1] != 3:
+        raise ValueError(
+            f"Expected `translation` to have shape (..., 3), got {translation.shape}."
+        )
+    device = xp_device(translation)
+    dtype = xp_result_type(translation, force_floating=True, xp=xp)
+    eye = xp.eye(4, dtype=dtype, device=device)
+
+    matrix = xpx.atleast_nd(eye, ndim=translation.ndim + 1, xp=xp)
+    matrix = xp.zeros(
+        (*translation.shape[:-1], 4, 4),
+        dtype=dtype,
+        device=device,
+    )
+    matrix = xpx.at(matrix)[...].set(xp.eye(4, dtype=dtype, device=device))
+    matrix = xpx.at(matrix)[..., :3, 3].set(
+        xp_promote(translation, force_floating=True, xp=xp)
+    )
+    return matrix
+
+
+def from_components(translation: Array, quat: Array) -> Array:
+    return compose_transforms(from_translation(translation), from_rotation(quat))
+
+
+def from_exp_coords(exp_coords: Array) -> Array:
+    rot_vec = exp_coords[..., :3]
+    rot_matrix = quat_as_matrix(quat_from_rotvec(rot_vec))
+    translation_transform = _compute_se3_exp_translation_transform(rot_vec)
+    translations = (translation_transform @ exp_coords[..., 3:, None])[..., 0]
+    return _create_transformation_matrix(translations, rot_matrix)
+
+
+def from_dual_quat(dual_quat: Array, *, scalar_first: bool = False) -> Array:
+    xp = array_namespace(dual_quat)
+
+    if dual_quat.shape[-1] != 8:
+        raise ValueError(
+            f"Expected `dual_quat` to have shape (..., 8), got {dual_quat.shape}."
+        )
+
+    real_part = dual_quat[..., :4]
+    dual_part = dual_quat[..., 4:]
+    if scalar_first:
+        real_part = xp.roll(real_part, -1, axis=-1)
+        dual_part = xp.roll(dual_part, -1, axis=-1)
+
+    real_part, dual_part = _normalize_dual_quaternion(real_part, dual_part)
+
+    rot_quat = from_quat(real_part)
+
+    translation = 2.0 * compose_quat(dual_part, quat_inv(rot_quat))[..., :3]
+    matrix = _create_transformation_matrix(translation, quat_as_matrix(rot_quat))
+
+    return matrix
+
+
+def as_exp_coords(matrix: Array) -> Array:
+    xp = array_namespace(matrix)
+    rot_vec = quat_as_rotvec(quat_from_matrix_orthogonal(matrix[..., :3, :3]))
+    translation_transform = _compute_se3_log_translation_transform(rot_vec)
+    translations = (translation_transform @ matrix[..., :3, 3][..., None])[..., 0]
+    exp_coords = xp.concat([rot_vec, translations], axis=-1)
+    return exp_coords
+
+
+def as_dual_quat(matrix: Array, *, scalar_first: bool = False) -> Array:
+    xp = array_namespace(matrix)
+    real_parts = quat_from_matrix_orthogonal(matrix[..., :3, :3])
+
+    pure_translation_quats = xp.empty(
+        (*matrix.shape[:-2], 4), dtype=matrix.dtype, device=xp_device(matrix)
+    )
+    pure_translation_quats = xpx.at(pure_translation_quats)[..., :3].set(
+        matrix[..., :3, 3]
+    )
+    pure_translation_quats = xpx.at(pure_translation_quats)[..., 3].set(0.0)
+
+    dual_parts = 0.5 * compose_quat(pure_translation_quats, real_parts)
+
+    if scalar_first:
+        real_parts = xp.roll(real_parts, 1, axis=-1)
+        dual_parts = xp.roll(dual_parts, 1, axis=-1)
+
+    dual_quats = xp.concat([real_parts, dual_parts], axis=-1)
+    return dual_quats
+
+
+def compose_transforms(tf_matrix: Array, other_tf_matrix: Array) -> Array:
+    if not broadcastable(tf_matrix.shape, other_tf_matrix.shape):
+        len_a = tf_matrix.shape[0] if tf_matrix.ndim == 3 else 1
+        len_b = other_tf_matrix.shape[0] if other_tf_matrix.ndim == 3 else 1
+        raise ValueError(
+            "Expected equal number of transforms in both or a "
+            "single transform in either object, got "
+            f"{len_a} transforms in first and {len_b}"
+            "transforms in second object."
+        )
+    return tf_matrix @ other_tf_matrix
+
+
+def inv(matrix: Array) -> Array:
+    xp = array_namespace(matrix)
+    r_inv = xp.matrix_transpose(matrix[..., :3, :3])
+    # Matrix multiplication of r_inv and translation vector
+    t_inv = -(r_inv @ matrix[..., :3, 3][..., None])[..., 0]
+    matrix = xp.zeros(
+        (*matrix.shape[:-2], 4, 4), dtype=matrix.dtype, device=xp_device(matrix)
+    )
+    matrix = xpx.at(matrix)[..., :3, :3].set(r_inv)
+    matrix = xpx.at(matrix)[..., :3, 3].set(t_inv)
+    matrix = xpx.at(matrix)[..., 3, 3].set(1)
+    return matrix
+
+
+def apply(matrix: Array, vector: Array, inverse: bool = False) -> Array:
+    xp = array_namespace(matrix)
+    if vector.shape[-1] != 3:
+        raise ValueError(f"Expected vector to have shape (..., 3), got {vector.shape}.")
+    vec = xp.empty(
+        (*vector.shape[:-1], 4), dtype=vector.dtype, device=xp_device(vector)
+    )
+    vec = xpx.at(vec)[..., :3].set(vector)
+    vec = xpx.at(vec)[..., 3].set(1)
+    vec = vec[..., None]
+
+    if inverse:
+        matrix = inv(matrix)
+
+    # We raise a ValueError manually here because letting the function run its course
+    # would raise heterogeneous error types and messages for different frameworks.
+    # However, the error only mimics numpy's error message and does not provide the
+    # same amount of context.
+    if not broadcastable(matrix.shape, vec.shape):  # type:ignore[arg-type]
+        raise ValueError("operands could not be broadcast together")
+    return (matrix @ vec)[..., :3, 0]
+
+
+def pow(matrix: Array, n: float | Array) -> Array:
+    xp = array_namespace(matrix)
+    device = xp_device(matrix)
+    # If n is an array, we sanitize it to a scalar and promote quat and n to
+    # the same dtype.
+    if is_array_api_obj(n):
+        if n.shape == (1,):  # type:ignore[union-attr]
+            n = n[0]  # type:ignore[index]
+        elif n.ndim != 0:  # type:ignore[union-attr]
+            raise ValueError("Array exponent must be a scalar")
+        matrix, n = xp_promote(matrix, n, force_floating=True, xp=xp)
+
+    # If n is a lazy array, we cannot take fast paths for special cases.
+    if is_lazy_array(n):
+        # Lazy execution. We compute all special cases and the general case
+        result = from_exp_coords(as_exp_coords(matrix) * n)
+        identity = xp.eye(4, dtype=matrix.dtype, device=device)
+        result = xp.where(n == 0, identity, result)
+        result = xp.where(n == -1, inv(matrix), result)
+        result = xp.where(n == 1, matrix, result)
+        return result
+    if n == 0:
+        identity = xp.eye(4, dtype=matrix.dtype, device=device)
+        identity = xpx.atleast_nd(identity, ndim=matrix.ndim, xp=xp)
+        return xp.tile(identity, (*matrix.shape[:-2], 1, 1))
+    elif n == -1:
+        return inv(matrix)
+    elif n == 1:
+        return matrix
+    return from_exp_coords(as_exp_coords(matrix) * n)
+
+
+def mean(
+    matrix: Array,
+    weights: ArrayLike | None = None,
+    axis: None | int | tuple[int, ...] = None
+) -> Array:
+    xp = array_namespace(matrix)
+    if matrix.shape[0] == 0:
+        raise ValueError("Mean of an empty rotation set is undefined.")
+    # Axis logic: For None, we reduce over all axes. For int, we only reduce over that
+    # axis. For tuple, we reduce over all specified axes.
+    all_axes = tuple(range(matrix.ndim - 2))
+    if axis is None:
+        axis = all_axes
+    elif isinstance(axis, int):
+        axis = (axis,)
+    if not isinstance(axis, tuple):
+        raise ValueError("`axis` must be None, int, or tuple of ints.")
+    # Ensure all axes are within bounds
+    if (axis != () and
+       (min(axis) < -(matrix.ndim - 2) or max(axis) > (matrix.ndim - 3))
+    ):
+        raise ValueError(
+            f"axis {axis} is out of bounds for transform with shape "
+            f"{matrix.shape[:-2]}."
+        )
+    # Ensure all axes are positive and unique
+    axis = tuple(sorted(set(x % (matrix.ndim - 2) for x in axis)))
+
+    lazy = is_lazy_array(matrix)
+    quats = quat_from_matrix_orthogonal(matrix[..., :3, :3])
+    if weights is None:
+        quats_mean = quat_mean(quats, axis=axis)
+    else:
+        neg_weights = weights < 0  # type:ignore[operator]
+        any_neg_weights = xp.any(neg_weights)
+        if not lazy and any_neg_weights:
+            raise ValueError("`weights` must be non-negative.")
+        if weights.shape != matrix.shape[:-2]:  # type:ignore[union-attr]
+            raise ValueError(
+                f"Expected `weights` to match transform shape, got shape "
+                f"{weights.shape} for {matrix.shape[:-2]} transformations."  # type:ignore[union-attr]
+            )
+        quats_mean = quat_mean(quats, weights=weights, axis=axis)
+    r_mean = quat_as_matrix(quats_mean)
+
+    t = matrix[..., :3, 3]
+    if weights is None:
+        t_mean = xp.mean(t, axis=axis)
+    else:
+        norm = xp.sum(weights[..., None], axis=axis)  # type:ignore[index]
+        wsum = xp.sum(t * weights[..., None], axis=axis)  # type:ignore[index]
+        t_mean = wsum / norm
+
+    tf = _create_transformation_matrix(t_mean, r_mean)
+    if weights is not None and lazy:
+        # We cannot raise on negative weights because jit code needs to be
+        # non-branching. We return NaN instead
+        mask = xp.where(any_neg_weights, xp.nan, 1.0)  # pyrefly:ignore[unbound-name]
+        tf = mask * tf
+    return tf
+
+
+def setitem(
+    matrix: Array,
+    indexer: Array | int | tuple | slice | EllipsisType | None,
+    value: Array,
+) -> Array:
+    xp = array_namespace(matrix)
+    if isinstance(indexer, EllipsisType):
+        return xpx.at(matrix)[indexer].set(value)
+    if is_array_api_obj(indexer) and indexer.dtype == xp.bool:  # type:ignore[union-attr]
+        return xpx.at(matrix)[indexer].set(value)  # type:ignore[index]
+    return xpx.at(matrix)[indexer, ...].set(value)  # type:ignore[index]
+
+
+def normalize_dual_quaternion(dual_quat: Array) -> Array:
+    """Normalize dual quaternion."""
+    xp = array_namespace(dual_quat)
+    real, dual = _normalize_dual_quaternion(dual_quat[..., :4], dual_quat[..., 4:])
+    return xp.concat((real, dual), axis=-1)
+
+
+def _create_transformation_matrix(
+    translations: Array, rotation_matrices: Array
+) -> Array:
+    if not translations.shape[:-1] == rotation_matrices.shape[:-2]:
+        raise ValueError(
+            "The number of rotation matrices and translations must be the same."
+        )
+    xp = array_namespace(translations)
+    matrix = xp.empty(
+        (*translations.shape[:-1], 4, 4),
+        dtype=translations.dtype,
+        device=xp_device(translations),
+    )
+    matrix = xpx.at(matrix)[..., :3, :3].set(rotation_matrices)
+    matrix = xpx.at(matrix)[..., :3, 3].set(translations)
+    matrix = xpx.at(matrix)[..., 3, :3].set(0)
+    matrix = xpx.at(matrix)[..., 3, 3].set(1)
+    return matrix
+
+
+def _compute_se3_exp_translation_transform(rot_vec: Array) -> Array:
+    """Compute the transformation matrix from the se3 translation part to SE3
+    translation.
+
+    The transformation matrix depends on the rotation vector.
+    """
+    xp = array_namespace(rot_vec)
+    device = xp_device(rot_vec)
+    dtype = rot_vec.dtype
+    angle = xp_vector_norm(rot_vec, axis=-1, keepdims=True, xp=xp)
+    small_scale = angle < 1e-3
+
+    k1_small = 0.5 - angle**2 / 24 + angle**4 / 720
+    # Avoid division by zero for non-branching computations. The value will get
+    # discarded in the xp.where selection.
+    safe_angle = angle + xp.asarray(small_scale, dtype=dtype, device=device)
+    k1 = (1.0 - xp.cos(angle)) / safe_angle**2
+    k1 = xp.where(small_scale, k1_small, k1)
+
+    k2_small = 1 / 6 - angle**2 / 120 + angle**4 / 5040
+    # Again, avoid division by zero by adding one to all near-zero angles.
+    safe_angle = angle + xp.asarray(small_scale, dtype=dtype, device=device)
+    k2 = (angle - xp.sin(angle)) / safe_angle**3
+    k2 = xp.where(small_scale, k2_small, k2)
+
+    s = _create_skew_matrix(rot_vec)
+    eye = xp.eye(3, dtype=dtype, device=device)
+
+    return eye + k1[..., None] * s + k2[..., None] * s @ s
+
+
+def _compute_se3_log_translation_transform(rot_vec: Array) -> Array:
+    """Compute the transformation matrix from SE3 translation to the se3
+    translation part.
+
+    It is the inverse of `_compute_se3_exp_translation_transform` in a closed
+    analytical form.
+    """
+    xp = array_namespace(rot_vec)
+    dtype = rot_vec.dtype
+    device = xp_device(rot_vec)
+    angle = xp_vector_norm(rot_vec, axis=-1, keepdims=True, xp=xp)
+    mask = angle < 1e-3
+
+    k_small = 1 / 12 + angle**2 / 720 + angle**4 / 30240
+    safe_angle = angle + xp.asarray(mask, dtype=dtype, device=device)
+    k = (1 - 0.5 * angle / xp.tan(0.5 * safe_angle)) / safe_angle**2
+    k = xp.where(mask, k_small, k)
+
+    s = _create_skew_matrix(rot_vec)
+
+    return xp.eye(3, dtype=dtype, device=device) - 0.5 * s + k[..., None] * s @ s
+
+
+def _create_skew_matrix(vec: Array) -> Array:
+    """Create skew-symmetric (aka cross-product) matrix for stack of vectors."""
+    xp = array_namespace(vec)
+    result = xp.zeros((*vec.shape[:-1], 3, 3), dtype=vec.dtype, device=xp_device(vec))
+    result = xpx.at(result)[..., 0, 1].set(-vec[..., 2])
+    result = xpx.at(result)[..., 0, 2].set(vec[..., 1])
+    result = xpx.at(result)[..., 1, 0].set(vec[..., 2])
+    result = xpx.at(result)[..., 1, 2].set(-vec[..., 0])
+    result = xpx.at(result)[..., 2, 0].set(-vec[..., 1])
+    result = xpx.at(result)[..., 2, 1].set(vec[..., 0])
+    return result
+
+
+def _normalize_dual_quaternion(
+    real_part: Array, dual_part: Array
+) -> tuple[Array, Array]:
+    """Ensure that the dual quaternion has unit norm.
+
+    The norm is a dual number and must be 1 + 0 * epsilon, which means that
+    the real quaternion must have unit norm and the dual quaternion must be
+    orthogonal to the real quaternion.
+    """
+    xp = array_namespace(real_part)
+
+    real_norm = xp_vector_norm(real_part, axis=-1, keepdims=True, xp=xp)
+
+    # special case: real quaternion is 0, we set it to identity
+    zero_real_mask = real_norm == 0.0
+    unit_quat = xp.asarray(
+        [0.0, 0.0, 0.0, 1.0], dtype=real_part.dtype, device=xp_device(real_part)
+    )
+    real_part = xp.where(zero_real_mask, unit_quat, real_part)
+    real_norm = xp.where(zero_real_mask, 1.0, real_norm)
+
+    # 1. ensure unit real quaternion
+    real_part = real_part / real_norm
+    dual_part = dual_part / real_norm
+
+    # 2. ensure orthogonality of real and dual quaternion
+    dual_part -= xp.sum(real_part * dual_part, axis=-1, keepdims=True) * real_part
+
+    return real_part, dual_part

v12x/pylib/scipy/spatial/transform/_rotation_groups.py

@@ -0,0 +1,140 @@
+import numpy as np
+from scipy.constants import golden as phi
+
+
+def icosahedral(cls):
+    g1 = tetrahedral(cls).as_quat()
+    a = 0.5
+    b = 0.5 / phi
+    c = phi / 2
+    g2 = np.array([[+a, +b, +c, 0],
+                   [+a, +b, -c, 0],
+                   [+a, +c, 0, +b],
+                   [+a, +c, 0, -b],
+                   [+a, -b, +c, 0],
+                   [+a, -b, -c, 0],
+                   [+a, -c, 0, +b],
+                   [+a, -c, 0, -b],
+                   [+a, 0, +b, +c],
+                   [+a, 0, +b, -c],
+                   [+a, 0, -b, +c],
+                   [+a, 0, -b, -c],
+                   [+b, +a, 0, +c],
+                   [+b, +a, 0, -c],
+                   [+b, +c, +a, 0],
+                   [+b, +c, -a, 0],
+                   [+b, -a, 0, +c],
+                   [+b, -a, 0, -c],
+                   [+b, -c, +a, 0],
+                   [+b, -c, -a, 0],
+                   [+b, 0, +c, +a],
+                   [+b, 0, +c, -a],
+                   [+b, 0, -c, +a],
+                   [+b, 0, -c, -a],
+                   [+c, +a, +b, 0],
+                   [+c, +a, -b, 0],
+                   [+c, +b, 0, +a],
+                   [+c, +b, 0, -a],
+                   [+c, -a, +b, 0],
+                   [+c, -a, -b, 0],
+                   [+c, -b, 0, +a],
+                   [+c, -b, 0, -a],
+                   [+c, 0, +a, +b],
+                   [+c, 0, +a, -b],
+                   [+c, 0, -a, +b],
+                   [+c, 0, -a, -b],
+                   [0, +a, +c, +b],
+                   [0, +a, +c, -b],
+                   [0, +a, -c, +b],
+                   [0, +a, -c, -b],
+                   [0, +b, +a, +c],
+                   [0, +b, +a, -c],
+                   [0, +b, -a, +c],
+                   [0, +b, -a, -c],
+                   [0, +c, +b, +a],
+                   [0, +c, +b, -a],
+                   [0, +c, -b, +a],
+                   [0, +c, -b, -a]])
+    return cls.from_quat(np.concatenate((g1, g2)))
+
+
+def octahedral(cls):
+    g1 = tetrahedral(cls).as_quat()
+    c = np.sqrt(2) / 2
+    g2 = np.array([[+c, 0, 0, +c],
+                   [0, +c, 0, +c],
+                   [0, 0, +c, +c],
+                   [0, 0, -c, +c],
+                   [0, -c, 0, +c],
+                   [-c, 0, 0, +c],
+                   [0, +c, +c, 0],
+                   [0, -c, +c, 0],
+                   [+c, 0, +c, 0],
+                   [-c, 0, +c, 0],
+                   [+c, +c, 0, 0],
+                   [-c, +c, 0, 0]])
+    return cls.from_quat(np.concatenate((g1, g2)))
+
+
+def tetrahedral(cls):
+    g1 = np.eye(4)
+    c = 0.5
+    g2 = np.array([[c, -c, -c, +c],
+                   [c, -c, +c, +c],
+                   [c, +c, -c, +c],
+                   [c, +c, +c, +c],
+                   [c, -c, -c, -c],
+                   [c, -c, +c, -c],
+                   [c, +c, -c, -c],
+                   [c, +c, +c, -c]])
+    return cls.from_quat(np.concatenate((g1, g2)))
+
+
+def dicyclic(cls, n, axis=2):
+    g1 = cyclic(cls, n, axis).as_rotvec()
+
+    thetas = np.linspace(0, np.pi, n, endpoint=False)
+    rv = np.pi * np.vstack([np.zeros(n), np.cos(thetas), np.sin(thetas)]).T
+    g2 = np.roll(rv, axis, axis=1)
+    return cls.from_rotvec(np.concatenate((g1, g2)))
+
+
+def cyclic(cls, n, axis=2):
+    thetas = np.linspace(0, 2 * np.pi, n, endpoint=False)
+    rv = np.vstack([thetas, np.zeros(n), np.zeros(n)]).T
+    return cls.from_rotvec(np.roll(rv, axis, axis=1))
+
+
+def create_group(cls, group, axis='Z'):
+    if not isinstance(group, str):
+        raise ValueError("`group` argument must be a string")
+
+    permitted_axes = ['x', 'y', 'z', 'X', 'Y', 'Z']
+    if axis not in permitted_axes:
+        raise ValueError("`axis` must be one of " + ", ".join(permitted_axes))
+
+    if group in ['I', 'O', 'T']:
+        symbol = group
+        order = 1
+    elif group[:1] in ['C', 'D'] and group[1:].isdigit():
+        symbol = group[:1]
+        order = int(group[1:])
+    else:
+        raise ValueError("`group` must be one of 'I', 'O', 'T', 'Dn', 'Cn'")
+
+    if order < 1:
+        raise ValueError("Group order must be positive")
+
+    axis = 'xyz'.index(axis.lower())
+    if symbol == 'I':
+        return icosahedral(cls)
+    elif symbol == 'O':
+        return octahedral(cls)
+    elif symbol == 'T':
+        return tetrahedral(cls)
+    elif symbol == 'D':
+        return dicyclic(cls, order, axis=axis)
+    elif symbol == 'C':
+        return cyclic(cls, order, axis=axis)
+    else:
+        assert False

v12x/pylib/scipy/spatial/transform/_rotation_spline.py

@@ -0,0 +1,465 @@
+import numpy as np
+from scipy.linalg import solve_banded
+from ._rotation import Rotation
+
+
+def _create_skew_matrix(x):
+    """Create skew-symmetric matrices corresponding to vectors.
+
+    Parameters
+    ----------
+    x : ndarray, shape (n, 3)
+        Set of vectors.
+
+    Returns
+    -------
+    ndarray, shape (n, 3, 3)
+    """
+    result = np.zeros((len(x), 3, 3))
+    result[:, 0, 1] = -x[:, 2]
+    result[:, 0, 2] = x[:, 1]
+    result[:, 1, 0] = x[:, 2]
+    result[:, 1, 2] = -x[:, 0]
+    result[:, 2, 0] = -x[:, 1]
+    result[:, 2, 1] = x[:, 0]
+    return result
+
+
+def _matrix_vector_product_of_stacks(A, b):
+    """Compute the product of stack of matrices and vectors."""
+    return np.einsum("ijk,ik->ij", A, b)
+
+
+def _angular_rate_to_rotvec_dot_matrix(rotvecs):
+    """Compute matrices to transform angular rates to rot. vector derivatives.
+
+    The matrices depend on the current attitude represented as a rotation
+    vector.
+
+    Parameters
+    ----------
+    rotvecs : ndarray, shape (n, 3)
+        Set of rotation vectors.
+
+    Returns
+    -------
+    ndarray, shape (n, 3, 3)
+    """
+    norm = np.linalg.norm(rotvecs, axis=1)
+    k = np.empty_like(norm)
+
+    mask = norm > 1e-4
+    nm = norm[mask]
+    k[mask] = (1 - 0.5 * nm / np.tan(0.5 * nm)) / nm**2
+    mask = ~mask
+    nm = norm[mask]
+    k[mask] = 1/12 + 1/720 * nm**2
+
+    skew = _create_skew_matrix(rotvecs)
+
+    result = np.empty((len(rotvecs), 3, 3))
+    result[:] = np.identity(3)
+    result[:] += 0.5 * skew
+    result[:] += k[:, None, None] * np.matmul(skew, skew)
+
+    return result
+
+
+def _rotvec_dot_to_angular_rate_matrix(rotvecs):
+    """Compute matrices to transform rot. vector derivatives to angular rates.
+
+    The matrices depend on the current attitude represented as a rotation
+    vector.
+
+    Parameters
+    ----------
+    rotvecs : ndarray, shape (n, 3)
+        Set of rotation vectors.
+
+    Returns
+    -------
+    ndarray, shape (n, 3, 3)
+    """
+    norm = np.linalg.norm(rotvecs, axis=1)
+    k1 = np.empty_like(norm)
+    k2 = np.empty_like(norm)
+
+    mask = norm > 1e-4
+    nm = norm[mask]
+    k1[mask] = (1 - np.cos(nm)) / nm ** 2
+    k2[mask] = (nm - np.sin(nm)) / nm ** 3
+
+    mask = ~mask
+    nm = norm[mask]
+    k1[mask] = 0.5 - nm ** 2 / 24
+    k2[mask] = 1 / 6 - nm ** 2 / 120
+
+    skew = _create_skew_matrix(rotvecs)
+
+    result = np.empty((len(rotvecs), 3, 3))
+    result[:] = np.identity(3)
+    result[:] -= k1[:, None, None] * skew
+    result[:] += k2[:, None, None] * np.matmul(skew, skew)
+
+    return result
+
+
+def _angular_acceleration_nonlinear_term(rotvecs, rotvecs_dot):
+    """Compute the non-linear term in angular acceleration.
+
+    The angular acceleration contains a quadratic term with respect to
+    the derivative of the rotation vector. This function computes that.
+
+    Parameters
+    ----------
+    rotvecs : ndarray, shape (n, 3)
+        Set of rotation vectors.
+    rotvecs_dot : ndarray, shape (n, 3)
+        Set of rotation vector derivatives.
+
+    Returns
+    -------
+    ndarray, shape (n, 3)
+    """
+    norm = np.linalg.norm(rotvecs, axis=1)
+    dp = np.sum(rotvecs * rotvecs_dot, axis=1)
+    cp = np.cross(rotvecs, rotvecs_dot)
+    ccp = np.cross(rotvecs, cp)
+    dccp = np.cross(rotvecs_dot, cp)
+
+    k1 = np.empty_like(norm)
+    k2 = np.empty_like(norm)
+    k3 = np.empty_like(norm)
+
+    mask = norm > 1e-4
+    nm = norm[mask]
+    k1[mask] = (-nm * np.sin(nm) - 2 * (np.cos(nm) - 1)) / nm ** 4
+    k2[mask] = (-2 * nm + 3 * np.sin(nm) - nm * np.cos(nm)) / nm ** 5
+    k3[mask] = (nm - np.sin(nm)) / nm ** 3
+
+    mask = ~mask
+    nm = norm[mask]
+    k1[mask] = 1/12 - nm ** 2 / 180
+    k2[mask] = -1/60 + nm ** 2 / 12604
+    k3[mask] = 1/6 - nm ** 2 / 120
+
+    dp = dp[:, None]
+    k1 = k1[:, None]
+    k2 = k2[:, None]
+    k3 = k3[:, None]
+
+    return dp * (k1 * cp + k2 * ccp) + k3 * dccp
+
+
+def _compute_angular_rate(rotvecs, rotvecs_dot):
+    """Compute angular rates given rotation vectors and its derivatives.
+
+    Parameters
+    ----------
+    rotvecs : ndarray, shape (n, 3)
+        Set of rotation vectors.
+    rotvecs_dot : ndarray, shape (n, 3)
+        Set of rotation vector derivatives.
+
+    Returns
+    -------
+    ndarray, shape (n, 3)
+    """
+    return _matrix_vector_product_of_stacks(
+        _rotvec_dot_to_angular_rate_matrix(rotvecs), rotvecs_dot)
+
+
+def _compute_angular_acceleration(rotvecs, rotvecs_dot, rotvecs_dot_dot):
+    """Compute angular acceleration given rotation vector and its derivatives.
+
+    Parameters
+    ----------
+    rotvecs : ndarray, shape (n, 3)
+        Set of rotation vectors.
+    rotvecs_dot : ndarray, shape (n, 3)
+        Set of rotation vector derivatives.
+    rotvecs_dot_dot : ndarray, shape (n, 3)
+        Set of rotation vector second derivatives.
+
+    Returns
+    -------
+    ndarray, shape (n, 3)
+    """
+    return (_compute_angular_rate(rotvecs, rotvecs_dot_dot) +
+            _angular_acceleration_nonlinear_term(rotvecs, rotvecs_dot))
+
+
+def _create_block_3_diagonal_matrix(A, B, d):
+    """Create a 3-diagonal block matrix as banded.
+
+    The matrix has the following structure:
+
+        DB...
+        ADB..
+        .ADB.
+        ..ADB
+        ...AD
+
+    The blocks A, B and D are 3-by-3 matrices. The D matrices has the form
+    d * I.
+
+    Parameters
+    ----------
+    A : ndarray, shape (n, 3, 3)
+        Stack of A blocks.
+    B : ndarray, shape (n, 3, 3)
+        Stack of B blocks.
+    d : ndarray, shape (n + 1,)
+        Values for diagonal blocks.
+
+    Returns
+    -------
+    ndarray, shape (11, 3 * (n + 1))
+        Matrix in the banded form as used by `scipy.linalg.solve_banded`.
+    """
+    ind = np.arange(3)
+    ind_blocks = np.arange(len(A))
+
+    A_i = np.empty_like(A, dtype=int)
+    A_i[:] = ind[:, None]
+    A_i += 3 * (1 + ind_blocks[:, None, None])
+
+    A_j = np.empty_like(A, dtype=int)
+    A_j[:] = ind
+    A_j += 3 * ind_blocks[:, None, None]
+
+    B_i = np.empty_like(B, dtype=int)
+    B_i[:] = ind[:, None]
+    B_i += 3 * ind_blocks[:, None, None]
+
+    B_j = np.empty_like(B, dtype=int)
+    B_j[:] = ind
+    B_j += 3 * (1 + ind_blocks[:, None, None])
+
+    diag_i = diag_j = np.arange(3 * len(d))
+    i = np.hstack((A_i.ravel(), B_i.ravel(), diag_i))
+    j = np.hstack((A_j.ravel(), B_j.ravel(), diag_j))
+    values = np.hstack((A.ravel(), B.ravel(), np.repeat(d, 3)))
+
+    u = 5
+    l = 5
+    result = np.zeros((u + l + 1, 3 * len(d)))
+    result[u + i - j, j] = values
+    return result
+
+
+class RotationSpline:
+    """Interpolate rotations with continuous angular rate and acceleration.
+
+    The rotation vectors between each consecutive orientation are cubic
+    functions of time and it is guaranteed that angular rate and acceleration
+    are continuous. Such interpolation are analogous to cubic spline
+    interpolation.
+
+    Refer to [1]_ for math and implementation details.
+
+    Parameters
+    ----------
+    times : array_like, shape (N,)
+        Times of the known rotations. At least 2 times must be specified.
+    rotations : `Rotation` instance
+        Rotations to perform the interpolation between. Must contain N
+        rotations.
+
+    Methods
+    -------
+    __call__
+
+    References
+    ----------
+    .. [1] `Smooth Attitude Interpolation
+            <https://github.com/scipy/scipy/files/2932755/attitude_interpolation.pdf>`_
+
+    Examples
+    --------
+    >>> from scipy.spatial.transform import Rotation, RotationSpline
+    >>> import numpy as np
+
+    Define the sequence of times and rotations from the Euler angles:
+
+    >>> times = [0, 10, 20, 40]
+    >>> angles = [[-10, 20, 30], [0, 15, 40], [-30, 45, 30], [20, 45, 90]]
+    >>> rotations = Rotation.from_euler('XYZ', angles, degrees=True)
+
+    Create the interpolator object:
+
+    >>> spline = RotationSpline(times, rotations)
+
+    Interpolate the Euler angles, angular rate and acceleration:
+
+    >>> angular_rate = np.rad2deg(spline(times, 1))
+    >>> angular_acceleration = np.rad2deg(spline(times, 2))
+    >>> times_plot = np.linspace(times[0], times[-1], 100)
+    >>> angles_plot = spline(times_plot).as_euler('XYZ', degrees=True)
+    >>> angular_rate_plot = np.rad2deg(spline(times_plot, 1))
+    >>> angular_acceleration_plot = np.rad2deg(spline(times_plot, 2))
+
+    On this plot you see that Euler angles are continuous and smooth:
+
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(times_plot, angles_plot)
+    >>> plt.plot(times, angles, 'x')
+    >>> plt.title("Euler angles")
+    >>> plt.show()
+
+    The angular rate is also smooth:
+
+    >>> plt.plot(times_plot, angular_rate_plot)
+    >>> plt.plot(times, angular_rate, 'x')
+    >>> plt.title("Angular rate")
+    >>> plt.show()
+
+    The angular acceleration is continuous, but not smooth. Also note that
+    the angular acceleration is not a piecewise-linear function, because
+    it is different from the second derivative of the rotation vector (which
+    is a piecewise-linear function as in the cubic spline).
+
+    >>> plt.plot(times_plot, angular_acceleration_plot)
+    >>> plt.plot(times, angular_acceleration, 'x')
+    >>> plt.title("Angular acceleration")
+    >>> plt.show()
+    """
+    # Parameters for the solver for angular rate.
+    MAX_ITER = 10
+    TOL = 1e-9
+
+    def _solve_for_angular_rates(self, dt, angular_rates, rotvecs):
+        angular_rate_first = angular_rates[0].copy()
+
+        A = _angular_rate_to_rotvec_dot_matrix(rotvecs)
+        A_inv = _rotvec_dot_to_angular_rate_matrix(rotvecs)
+        M = _create_block_3_diagonal_matrix(
+            2 * A_inv[1:-1] / dt[1:-1, None, None],
+            2 * A[1:-1] / dt[1:-1, None, None],
+            4 * (1 / dt[:-1] + 1 / dt[1:]))
+
+        b0 = 6 * (rotvecs[:-1] * dt[:-1, None] ** -2 +
+                  rotvecs[1:] * dt[1:, None] ** -2)
+        b0[0] -= 2 / dt[0] * A_inv[0].dot(angular_rate_first)
+        b0[-1] -= 2 / dt[-1] * A[-1].dot(angular_rates[-1])
+
+        for iteration in range(self.MAX_ITER):
+            rotvecs_dot = _matrix_vector_product_of_stacks(A, angular_rates)
+            delta_beta = _angular_acceleration_nonlinear_term(
+                rotvecs[:-1], rotvecs_dot[:-1])
+            b = b0 - delta_beta
+            angular_rates_new = solve_banded((5, 5), M, b.ravel())
+            angular_rates_new = angular_rates_new.reshape((-1, 3))
+
+            delta = np.abs(angular_rates_new - angular_rates[:-1])
+            angular_rates[:-1] = angular_rates_new
+            if np.all(delta < self.TOL * (1 + np.abs(angular_rates_new))):
+                break
+
+        rotvecs_dot = _matrix_vector_product_of_stacks(A, angular_rates)
+        angular_rates = np.vstack((angular_rate_first, angular_rates[:-1]))
+
+        return angular_rates, rotvecs_dot
+
+    def __init__(self, times, rotations):
+        from scipy.interpolate import PPoly
+
+        if rotations.single:
+            raise ValueError("`rotations` must be a sequence of rotations.")
+
+        if rotations.as_quat().ndim > 2:
+            raise ValueError(
+                "Rotations with more than 1 leading dimension are not supported."
+            )
+
+        if len(rotations) == 1:
+            raise ValueError("`rotations` must contain at least 2 rotations.")
+
+        times = np.asarray(times, dtype=float)
+        if times.ndim != 1:
+            raise ValueError("`times` must be 1-dimensional.")
+
+        if len(times) != len(rotations):
+            raise ValueError("Expected number of rotations to be equal to "
+                             "number of timestamps given, "
+                             f"got {len(rotations)} rotations "
+                             f"and {len(times)} timestamps.")
+
+        dt = np.diff(times)
+        if np.any(dt <= 0):
+            raise ValueError("Values in `times` must be in a strictly "
+                             "increasing order.")
+
+        rotvecs = (rotations[:-1].inv() * rotations[1:]).as_rotvec()
+        angular_rates = rotvecs / dt[:, None]
+
+        if len(rotations) == 2:
+            rotvecs_dot = angular_rates
+        else:
+            angular_rates, rotvecs_dot = self._solve_for_angular_rates(
+                dt, angular_rates, rotvecs)
+
+        dt = dt[:, None]
+        coeff = np.empty((4, len(times) - 1, 3))
+        coeff[0] = (-2 * rotvecs + dt * angular_rates
+                    + dt * rotvecs_dot) / dt ** 3
+        coeff[1] = (3 * rotvecs - 2 * dt * angular_rates
+                    - dt * rotvecs_dot) / dt ** 2
+        coeff[2] = angular_rates
+        coeff[3] = 0
+
+        self.times = times
+        self.rotations = rotations
+        self.interpolator = PPoly(coeff, times)
+
+    def __call__(self, times, order=0):
+        """Compute interpolated values.
+
+        Parameters
+        ----------
+        times : float or array_like
+            Times of interest.
+        order : {0, 1, 2}, optional
+            Order of differentiation:
+
+                * 0 (default) : return Rotation
+                * 1 : return the angular rate in rad/sec
+                * 2 : return the angular acceleration in rad/sec/sec
+
+        Returns
+        -------
+        Interpolated Rotation, angular rate or acceleration.
+        """
+        if order not in [0, 1, 2]:
+            raise ValueError("`order` must be 0, 1 or 2.")
+
+        times = np.asarray(times, dtype=float)
+        if times.ndim > 1:
+            raise ValueError("`times` must be at most 1-dimensional.")
+
+        singe_time = times.ndim == 0
+        times = np.atleast_1d(times)
+
+        rotvecs = self.interpolator(times)
+        if order == 0:
+            index = np.searchsorted(self.times, times, side='right')
+            index -= 1
+            index[index < 0] = 0
+            n_segments = len(self.times) - 1
+            index[index > n_segments - 1] = n_segments - 1
+            result = self.rotations[index] * Rotation.from_rotvec(rotvecs)
+        elif order == 1:
+            rotvecs_dot = self.interpolator(times, 1)
+            result = _compute_angular_rate(rotvecs, rotvecs_dot)
+        elif order == 2:
+            rotvecs_dot = self.interpolator(times, 1)
+            rotvecs_dot_dot = self.interpolator(times, 2)
+            result = _compute_angular_acceleration(rotvecs, rotvecs_dot,
+                                                   rotvecs_dot_dot)
+        else:
+            assert False
+
+        if singe_time:
+            result = result[0]
+
+        return result

v12x/pylib/scipy/spatial/transform/_rotation_xp.py

@@ -0,0 +1,1140 @@
+"""Array API backend for the `Rotation` class.
+
+This module provides generic, functional implementations of the `Rotation` class methods
+that work with any Array API-compatible backend.
+"""
+
+# Parts of the implementation are adapted from the cython backend and
+# https://github.com/jax-ml/jax/blob/d695aa4c63ffcebefce52794427c46bad576680c/jax/_src/scipy/spatial/transform.py.
+import re
+import warnings
+from types import EllipsisType
+
+import numpy as np
+from scipy._lib._array_api import (
+    array_namespace,
+    Array,
+    ArrayLike,
+    is_lazy_array,
+    xp_vector_norm,
+    xp_result_type,
+    xp_promote,
+    is_jax,
+)
+from scipy._lib._util import broadcastable
+from scipy._external.array_api_compat import device as xp_device
+from scipy._external.array_api_compat import is_array_api_obj
+import scipy._external.array_api_extra as xpx
+
+# mypy: disable-error-code=index
+# mypy: disable-error-code=operator
+# mypy: disable-error-code=union-attr
+
+def from_quat(
+    quat: Array,
+    normalize: bool = True,
+    copy: bool = True,
+    *,
+    scalar_first: bool = False,
+) -> Array:
+    xp = array_namespace(quat)
+    if scalar_first:
+        quat = xp.roll(quat, -1, axis=-1)
+    # Normalize will always copy, so we avoid the extra copy if we normalize
+    if copy and not normalize:
+        quat = xp.asarray(quat, copy=True)
+    if normalize:
+        quat = _normalize_quaternion(quat)
+    return quat
+
+
+def from_matrix(matrix: Array, assume_valid: bool = False) -> Array:
+    xp = array_namespace(matrix)
+    device = xp_device(matrix)
+
+    if not assume_valid:
+        mask = xp.linalg.det(matrix) <= 0
+        lazy = is_lazy_array(mask)
+        # Only non-lazy backends raise an error for non-positive determinants.
+        if not lazy and xp.any(mask):
+            ind = int(xp.nonzero(xpx.atleast_nd(mask, ndim=1, xp=xp))[0][0])
+            raise ValueError(
+                "Non-positive determinant (left-handed or null coordinate frame) in "
+                f"rotation matrix {ind}: {matrix[ind, ...]}."
+            )
+        elif lazy:
+            matrix = xp.where(mask[..., None, None], xp.nan, matrix)
+
+        gramians = matrix @ xp.matrix_transpose(matrix)
+        eye = xp.eye(3, dtype=matrix.dtype, device=device)
+        is_orthogonal = xp.all(
+            xpx.isclose(gramians, eye, atol=1e-12, xp=xp), axis=(-2, -1)
+        )
+
+        if lazy:
+            # Lazy backends do not support non-concrete boolean indexing or any form of
+            # computation without statically known shapes, so we always compute SVD and
+            # use xp.where to select the result.
+            U, _, Vt = xp.linalg.svd(matrix, full_matrices=False)
+            matrix = xp.where(is_orthogonal[..., None, None], matrix, U @ Vt)
+        elif not xp.all(is_orthogonal):
+            # For eager frameworks, only compute SVD if needed.
+            is_not_orthogonal = ~is_orthogonal
+            U, _, Vt = xp.linalg.svd(matrix[is_not_orthogonal], full_matrices=False)
+            matrix = xpx.at(matrix)[is_not_orthogonal].set(U @ Vt)
+
+    return _from_matrix_orthogonal(matrix)
+
+
+def _from_matrix_orthogonal(matrix: Array) -> Array:
+    """Convert known orthogonal rotation matrix to quaternion"""
+    xp = array_namespace(matrix)
+    device = xp_device(matrix)
+
+    matrix_trace = matrix[..., 0, 0] + matrix[..., 1, 1] + matrix[..., 2, 2]
+    decision = xp.stack(
+        [matrix[..., 0, 0], matrix[..., 1, 1], matrix[..., 2, 2], matrix_trace],
+        axis=-1,
+    )
+    choice = xp.argmax(decision, axis=-1, keepdims=True)
+    quat = xp.empty((*matrix.shape[:-2], 4), dtype=matrix.dtype, device=device)
+
+    # The Array API does not support mixing integer indexing with ellipsis, so we cannot
+    # follow the same pattern as the cython backend. Instead, we compute each case
+    # explicitly and assemble the final result with `xp.where`.
+    # TODO: Revisit this implementation if the array API supports mixed integer and
+    # ellipsis indexing.
+
+    # Case 0
+    quat_0 = xp.stack(
+        [
+            1 - matrix_trace[...] + 2 * matrix[..., 0, 0],
+            matrix[..., 1, 0] + matrix[..., 0, 1],
+            matrix[..., 2, 0] + matrix[..., 0, 2],
+            matrix[..., 2, 1] - matrix[..., 1, 2],
+        ],
+        axis=-1,
+    )
+    quat = xp.where(choice == 0, quat_0, quat)
+
+    # Case 1
+    quat_1 = xp.stack(
+        [
+            matrix[..., 1, 0] + matrix[..., 0, 1],
+            1 - matrix_trace[...] + 2 * matrix[..., 1, 1],
+            matrix[..., 2, 1] + matrix[..., 1, 2],
+            matrix[..., 0, 2] - matrix[..., 2, 0],
+        ],
+        axis=-1,
+    )
+    quat = xp.where(choice == 1, quat_1, quat)
+
+    # Case 2
+    quat_2 = xp.stack(
+        [
+            matrix[..., 2, 0] + matrix[..., 0, 2],
+            matrix[..., 2, 1] + matrix[..., 1, 2],
+            1 - matrix_trace[...] + 2 * matrix[..., 2, 2],
+            matrix[..., 1, 0] - matrix[..., 0, 1],
+        ],
+        axis=-1,
+    )
+    quat = xp.where(choice == 2, quat_2, quat)
+
+    # Case 3
+    quat_3 = xp.stack(
+        [
+            matrix[..., 2, 1] - matrix[..., 1, 2],
+            matrix[..., 0, 2] - matrix[..., 2, 0],
+            matrix[..., 1, 0] - matrix[..., 0, 1],
+            1 + matrix_trace[...],
+        ],
+        axis=-1,
+    )
+    quat = xp.where(choice == 3, quat_3, quat)
+
+    return _normalize_quaternion(quat)
+
+
+def from_rotvec(rotvec: Array, degrees: bool = False) -> Array:
+    xp = array_namespace(rotvec)
+    if rotvec.shape[-1] != 3:
+        raise ValueError(
+            f"Expected `rot_vec` to have shape (..., 3), got {rotvec.shape}"
+        )
+    rotvec = _deg2rad(rotvec) if degrees else rotvec
+
+    angle = xp_vector_norm(rotvec, axis=-1, keepdims=True, xp=xp)
+    small_angle = angle <= 1e-3
+    angle2 = angle**2
+    small_scale = 0.5 - angle2 / 48 + angle2**2 / 3840
+    # We need to handle the case where angle is 0 to avoid division by zero. We use the
+    # value of the Taylor series approximation, but non-branching operations require
+    # that we still divide by the angle. Since we do not use the result where the angle
+    # is close to 0, this is safe.
+    div_angle = angle + xp.asarray(small_angle, dtype=angle.dtype)
+    large_scale = xp.sin(angle / 2) / div_angle
+    scale = xp.where(small_angle, small_scale, large_scale)
+    quat = xp.concat([rotvec * scale, xp.cos(angle / 2)], axis=-1)
+    return quat
+
+
+def from_mrp(mrp: Array) -> Array:
+    xp = array_namespace(mrp)
+    if mrp.shape[-1] != 3:
+        raise ValueError(f"Expected `mrp` to have shape (..., 3), got {mrp.shape}")
+    mrp2_plus_1 = xp.linalg.vecdot(mrp, mrp, axis=-1)[..., None] + 1
+    q_no_norm = xp.concat([2 * mrp[..., :3], (2 - mrp2_plus_1)], axis=-1)
+    quat = q_no_norm / mrp2_plus_1
+    return quat
+
+
+def from_euler(seq: str, angles: Array, degrees: bool = False) -> Array:
+    xp = array_namespace(angles)
+    num_axes = len(seq)
+    if num_axes < 1 or num_axes > 3:
+        raise ValueError(
+            "Expected axis specification to be a non-empty "
+            f"string of up to 3 characters, got {seq}"
+        )
+
+    intrinsic = re.match(r"^[XYZ]{1,3}$", seq) is not None
+    extrinsic = re.match(r"^[xyz]{1,3}$", seq) is not None
+    if not (intrinsic or extrinsic):
+        raise ValueError(
+            "Expected axes from `seq` to be from ['x', 'y', "
+            f"'z'] or ['X', 'Y', 'Z'], got {seq}"
+        )
+
+    if any(seq[i] == seq[i + 1] for i in range(num_axes - 1)):
+        raise ValueError(f"Expected consecutive axes to be different, got {seq}")
+
+    if degrees:
+        angles = _deg2rad(angles)
+
+    angles = xpx.atleast_nd(angles, ndim=1, xp=xp)
+
+    if angles.shape[-1] != num_axes:
+        raise ValueError(
+            "Expected last dimension of `angles` to match number of sequence axes "
+            f"specified, got {angles.shape[-1]}."
+        )
+    axes = [_elementary_basis_index(x) for x in seq.lower()]
+    q = _elementary_quat_compose(axes, angles, intrinsic)
+    return q
+
+
+def from_davenport(
+    axes: Array, order: str, angles: Array, degrees: bool = False
+) -> Array:
+    xp = array_namespace(axes)
+    device = xp_device(axes)
+    if order in ["e", "extrinsic"]:  # Must be static, cannot be jitted
+        extrinsic = True
+    elif order in ["i", "intrinsic"]:
+        extrinsic = False
+    else:
+        raise ValueError(
+            "order should be 'e'/'extrinsic' for extrinsic sequences or 'i'/"
+            f"'intrinsic' for intrinsic sequences, got {order}"
+        )
+
+    if axes.shape[-1] != 3:
+        raise ValueError("Axes must be vectors of length 3.")
+
+    axes = xpx.atleast_nd(axes, ndim=2, xp=xp)
+    angles = xpx.atleast_nd(angles, ndim=1, xp=xp) 
+    num_axes = axes.shape[-2]
+    if num_axes < 1 or num_axes > 3:
+        raise ValueError(f"Expected up to 3 axes, got {num_axes}")
+
+    axes = axes / xp_vector_norm(axes, axis=-1, keepdims=True, xp=xp)
+
+    # Check if axes are orthogonal. Shape checks also work for lazy backends.
+    axes_not_orthogonal = xp.zeros(axes.shape[:-2], dtype=xp.bool, device=device)
+    if num_axes > 1:
+        # Cannot be True yet, so we do not need to use xp.logical_or
+        axes_not_orthogonal = axes_not_orthogonal | (
+            xp.abs(xp.vecdot(axes[..., 0, :], axes[..., 1, :])) > 1e-7
+        )
+    if num_axes > 2:
+        axes_not_orthogonal = axes_not_orthogonal | (
+            xp.abs(xp.vecdot(axes[..., 1, :], axes[..., 2, :])) > 1e-7
+        )
+    if not is_lazy_array(axes_not_orthogonal) and xp.any(axes_not_orthogonal):
+        raise ValueError("Consecutive axes must be orthogonal.")
+    else:
+        axes = xp.where(axes_not_orthogonal[..., None, None], xp.nan, axes)
+
+    if degrees:
+        angles = _deg2rad(angles)
+
+    if (
+        not broadcastable(axes.shape[:-1], angles.shape)
+        or axes.shape[-2] != angles.shape[-1]
+    ):
+        raise ValueError(
+            f"Expected `angles` to match number of axes, got {angles.shape} angles "
+            f"and {axes.shape} axes."
+        )
+
+    q_shape = angles.shape[:-1] + (4,)
+    q = xp.zeros(q_shape, dtype=angles.dtype, device=xp_device(angles))
+    q = xpx.at(q)[..., 3].set(1)
+
+    for i in range(num_axes):
+        qi = from_rotvec(angles[..., i, None] * axes[..., i, :])
+        q = compose_quat(qi, q) if extrinsic else compose_quat(q, qi)
+    return q
+
+
+def as_quat(
+    quat: Array, canonical: bool = False, *, scalar_first: bool = False
+) -> Array:
+    xp = array_namespace(quat)
+    if canonical:
+        quat = _quat_canonical(quat)
+    if scalar_first:
+        quat = xp.roll(quat, 1, axis=-1)
+    return quat
+
+
+def as_matrix(quat: Array) -> Array:
+    xp = array_namespace(quat)
+    x = quat[..., 0]
+    y = quat[..., 1]
+    z = quat[..., 2]
+    w = quat[..., 3]
+
+    x2 = x * x
+    y2 = y * y
+    z2 = z * z
+    w2 = w * w
+
+    xy = x * y
+    zw = z * w
+    xz = x * z
+    yw = y * w
+    yz = y * z
+    xw = x * w
+
+    matrix_elements = [
+        x2 - y2 - z2 + w2,
+        2 * (xy - zw),
+        2 * (xz + yw),
+        2 * (xy + zw),
+        -x2 + y2 - z2 + w2,
+        2 * (yz - xw),
+        2 * (xz - yw),
+        2 * (yz + xw),
+        -x2 - y2 + z2 + w2,
+    ]
+    matrix = xp.reshape(xp.stack(matrix_elements, axis=-1), (*quat.shape[:-1], 3, 3))
+    return matrix
+
+
+def as_rotvec(quat: Array, degrees: bool = False) -> Array:
+    xp = array_namespace(quat)
+    quat = _quat_canonical(quat)
+    ax_norm = xp_vector_norm(quat[..., :3], axis=-1, keepdims=True, xp=xp)
+    angle = 2 * xp.atan2(ax_norm, quat[..., 3][..., None])
+    small_angle = angle <= 1e-3
+    angle2 = angle**2
+    small_scale = 2 + angle2 / 12 + 7 * angle2**2 / 2880
+    # We need to handle the case where sin(angle/2) is 0 to avoid division by zero. We
+    # use the value of the Taylor series approximation, but non-branching operations
+    # require that we still divide by the sin. Since we do not use the result where the
+    # angle is close to 0, adding one to the sin where we discard the result is safe.
+    div_sin = xp.sin(angle / 2.0) + xp.asarray(small_angle, dtype=angle.dtype)
+    large_scale = angle / div_sin
+    scale = xp.where(small_angle, small_scale, large_scale)
+    if degrees:
+        scale = _rad2deg(scale)
+    rotvec = scale * quat[..., :3]
+    return rotvec
+
+
+def as_mrp(quat: Array) -> Array:
+    xp = array_namespace(quat)
+    one = xp.asarray(1.0, device=xp_device(quat), dtype=quat.dtype)
+    sign = xp.where(quat[..., 3, None] < 0, -1, one)
+    denominator = 1.0 + sign * quat[..., 3, None]
+    return sign * quat[..., :3] / denominator
+
+
+def as_euler(
+    quat: Array, seq: str, degrees: bool = False, *, suppress_warnings: bool = False
+) -> Array:
+    xp = array_namespace(quat)
+
+    # Sanitize the sequence
+    if len(seq) != 3:
+        raise ValueError(f"Expected 3 axes, got {seq}.")
+    intrinsic = re.match(r"^[XYZ]{1,3}$", seq) is not None
+    extrinsic = re.match(r"^[xyz]{1,3}$", seq) is not None
+    if not (intrinsic or extrinsic):
+        raise ValueError(
+            "Expected axes from `seq` to be from ['x', 'y', 'z'] or ['X', 'Y', 'Z'], "
+            f"got {seq}"
+        )
+    if any(seq[i] == seq[i + 1] for i in range(2)):
+        raise ValueError(f"Expected consecutive axes to be different, got {seq}")
+
+    device = xp_device(quat)
+    axes = [_elementary_basis_index(x) for x in seq.lower()]
+    axes = axes if extrinsic else axes[::-1]
+    i, j, k = axes
+    symmetric = i == k
+    k = 3 - i - j if symmetric else k
+
+    mask = xp.asarray(symmetric, device=device)
+    sign = xp.asarray((i - j) * (j - k) * (k - i) // 2, dtype=quat.dtype, device=device)
+    # Permute quaternion elements
+    a = xp.where(mask, quat[..., 3], quat[..., 3] - quat[..., j])
+    b = xp.where(mask, quat[..., i], quat[..., i] + quat[..., k] * sign)
+    c = xp.where(mask, quat[..., j], quat[..., j] + quat[..., 3])
+    d = xp.where(mask, quat[..., k] * sign, quat[..., k] * sign - quat[..., i])
+
+    angles = _get_angles(
+        extrinsic, symmetric, sign, xp.pi / 2, a, b, c, d, suppress_warnings
+    )
+    return _rad2deg(angles) if degrees else angles
+
+
+def as_davenport(
+    quat: Array,
+    axes: Array,
+    order: str,
+    degrees: bool = False,
+    *,
+    suppress_warnings: bool = False,
+) -> Array:
+    xp = array_namespace(quat)
+
+    # Check argument validity
+    if order in ["e", "extrinsic"]:
+        extrinsic = True
+    elif order in ["i", "intrinsic"]:
+        extrinsic = False
+    else:
+        raise ValueError(
+            "order should be 'e'/'extrinsic' for extrinsic sequences or 'i'/'intrinsic'"
+            f" for intrinsic sequences, got {order}"
+        )
+    if axes.shape[-2] != 3:
+        raise ValueError(f"Expected 3 axes, got {axes.shape}.")
+    if axes.shape[-1] != 3:
+        raise ValueError("Axes must be vectors of length 3.")
+    if not broadcastable(axes.shape[:-2], quat.shape[:-1]):
+        raise ValueError(
+            f"Expected `axes` to match number of rotations, got {axes.shape} axes "
+            f"and {quat.shape} rotations."
+        )
+
+    # normalize axes
+    axes = axes / xp_vector_norm(axes, axis=-1, keepdims=True, xp=xp)
+    vdot_ax0_ax1 = xp.vecdot(axes[..., 0, :], axes[..., 1, :])
+    vdot_ax1_ax2 = xp.vecdot(axes[..., 1, :], axes[..., 2, :])
+    is_invalid = (vdot_ax0_ax1 >= 1e-7) | (vdot_ax1_ax2 >= 1e-7)
+    if is_lazy_array(is_invalid):
+        axes = xp.where(is_invalid[..., None, None], xp.nan, axes)
+    elif xp.any(is_invalid):
+        raise ValueError("Consecutive axes must be orthogonal.")
+
+    angles = _compute_davenport_from_quat(
+        quat,
+        axes[..., 0, :],
+        axes[..., 1, :],
+        axes[..., 2, :],
+        extrinsic,
+        suppress_warnings,
+    )
+    if degrees:
+        angles = _rad2deg(angles)
+    return angles
+
+
+def inv(quat: Array) -> Array:
+    return xpx.at(quat)[..., :3].multiply(-1, copy=True)
+
+
+def magnitude(quat: Array) -> Array:
+    xp = array_namespace(quat)
+    sin_q = xp_vector_norm(quat[..., :3], axis=-1, xp=xp)
+    cos_q = xp.abs(quat[..., 3])
+    angles = 2 * xp.atan2(sin_q, cos_q)
+    return angles
+
+
+def approx_equal(
+    quat: Array, other: Array, atol: float | None = None, degrees: bool = False
+) -> Array:
+    if atol is None:
+        if degrees:
+            warnings.warn(
+                "atol must be set to use the degrees flag, defaulting to 1e-8 radians.",
+                stacklevel=2,
+            )
+        atol = 1e-8
+    elif degrees:
+        atol = _deg2rad(atol)
+
+    if not broadcastable(quat.shape, other.shape):
+        raise ValueError(
+            f"Expected broadcastable shapes in both rotations, got {quat.shape[:-1]} "
+            f"rotations in first and {other.shape[:-1]} rotations in second object."
+        )
+
+    quat_result = compose_quat(other, inv(quat))
+    angles = magnitude(quat_result)
+    return angles < atol
+
+
+def mean(
+    quat: Array,
+    weights: ArrayLike | None = None,
+    axis: None | int | tuple[int, ...] = None,
+) -> Array:
+    xp = array_namespace(quat)
+    device = xp_device(quat)
+    dtype = xp_result_type(quat, force_floating=True, xp=xp)
+    if quat.shape[0] == 0:
+        raise ValueError("Mean of an empty rotation set is undefined.")
+    # Axis logic: For None, we reduce over all axes. For int, we only reduce over that
+    # axis. For tuple, we reduce over all specified axes.
+    all_axes = tuple(range(quat.ndim - 1))
+    if axis is None:
+        axis = all_axes
+    elif isinstance(axis, int):
+        axis = (axis,)
+    if not isinstance(axis, tuple):
+        raise ValueError("`axis` must be None, int, or tuple of ints.")
+    # Ensure all axes are within bounds
+    if axis != () and (min(axis) < -(quat.ndim - 1) or max(axis) > (quat.ndim - 2)):
+        raise ValueError(
+            f"axis {axis} is out of bounds for rotation with shape {quat.shape[:-1]}."
+        )
+    # Ensure all axes are positive and unique
+    axis = tuple(sorted(set(x % (quat.ndim - 1) for x in axis)))
+
+    lazy = is_lazy_array(quat)
+    # Branching code is okay for checks that include meta info such as shapes and types
+    quat_expand = quat[..., None, :]
+    if weights is None:
+        K = xp.matrix_transpose(quat_expand) @ quat_expand
+    else:
+        weights = xp.asarray(weights, dtype=dtype, device=device)
+        neg_weights = weights < 0
+        if not lazy and xp.any(neg_weights):
+            raise ValueError("`weights` must be non-negative.")
+        elif lazy:
+            # We cannot check for negative weights because jit code needs to be
+            # non-branching. We return NaN instead
+            weights = xp.where(neg_weights, xp.nan, weights)
+
+        if not broadcastable(quat.shape[:-1], weights.shape):
+            raise ValueError(
+                "Expected `weights` to be broadcastable to rotation shape, got shape "
+                f"{weights.shape} for {quat.shape[:-1]} rotations."
+            )
+
+        # Make sure we can transpose quat
+        weighted_quat = weights[..., None, None] * quat_expand
+        K = xp.matrix_transpose(weighted_quat) @ quat_expand
+
+    # Move reduction axes to the end
+    keep_axes = tuple(i for i in all_axes if i not in axis)
+    axes_order = keep_axes + axis
+    K_reordered = xp.moveaxis(K, axes_order, all_axes)
+    # Reshape to flatten reduction axes
+    new_shape = K_reordered.shape[: len(keep_axes)] + (-1, 4, 4)
+    K = xp.mean(xp.reshape(K_reordered, new_shape), axis=-3)
+    _, v = xp.linalg.eigh(K)
+    return v[..., -1]
+
+
+def reduce(
+    quat: Array,
+    left: Array | None = None,
+    right: Array | None = None,
+) -> tuple[Array, Array | None, Array | None]:
+    if left is None and right is None:
+        return quat, None, None
+    # DECISION: We cannot have variable number of return arguments for jit compiled
+    # functions. We therefore always return the indices, and filter out later.
+    # TOOD: Properly support broadcasting.
+    xp = array_namespace(quat)
+    quat = xpx.atleast_nd(quat, ndim=2, xp=xp)
+    if left is None:
+        left = xp.ones_like(quat)
+    if right is None:
+        right = xp.ones_like(quat)
+
+    # We want to calculate the real components of q = l * p * r. It can
+    # be shown that:
+    #     qs = ls * ps * rs - ls * dot(pv, rv) - ps * dot(lv, rv)
+    #          - rs * dot(lv, pv) - dot(cross(lv, pv), rv)
+    # where ls and lv denote the scalar and vector components of l.
+
+    p = quat
+    ps, pv = _split_rotation(p, xp)
+    ls, lv = _split_rotation(left, xp)
+    rs, rv = _split_rotation(right, xp)
+
+    # Compute each term without einsum (not accessible in the Array API)
+    # First term: np.einsum("i,j,k", ls, ps, rs)
+    term1 = ls[..., :, None, None] * ps[..., None, :, None] * rs[..., None, None, :]
+    # Second term: np.einsum('i,jx,kx', ls, pv, rv)
+    prv = xp.sum(pv[..., :, None, :] * rv[..., None, :, :], axis=-1)
+    term2 = ls[..., :, None, None] * prv[..., None, :, :]
+    # Third term: np.einsum('ix,j,kx', lv, ps, rv)
+    lrv = xp.sum(lv[..., :, None, :] * rv[..., None, :, :], axis=-1)
+    term3 = ps[..., None, :, None] * lrv[..., :, None, :]
+    # Fourth term: np.einsum('ix,jx,k', lv, pv, rs)
+    lpv = xp.sum(lv[..., :, None, :] * pv[..., None, :, :], axis=-1)
+    term4 = rs[..., None, None, :] * lpv[..., :, :, None]
+    # Fifth term: np.einsum('xyz,ix,jy,kz', e, lv, pv, rv). We want to avoid expanding
+    # the einsum into a 6D tensor to avoid excessive memory usage. Instead, we compute
+    # the cross product between lv and pv and then compute the dot product with rv.
+    # First compute cross products between lv and pv
+    lv_expanded = lv[..., :, None, :]
+    pv_expanded = pv[..., None, :, :]
+    cross_lp = xp.linalg.cross(lv_expanded, pv_expanded)
+    # Then compute dot product with rv
+    term5 = xp.sum(cross_lp[..., :, :, None, :] * rv[..., None, None, :, :], axis=-1)
+    # Combine all terms with proper shape alignment
+    qs = xp.abs(term1 - term2 - term3 - term4 - term5)
+    qs = xp.reshape(xp.moveaxis(qs, 1, 0), (qs.shape[1], -1))
+
+    # Find best indices from scalar components
+    max_ind = xp.argmax(xp.reshape(qs, (qs.shape[0], -1)), axis=1)
+    left_best = max_ind // rv.shape[0]
+    right_best = max_ind % rv.shape[0]
+    # Array API limitation: Integer index arrays are only allowed with integer indices
+    # TODO: Can we somehow avoid this?
+    all_idx = xp.reshape(xp.arange(left.shape[-1]), (1, -1))
+    left_idx = xp.reshape(left_best, (-1, 1))
+    left = left[left_idx, all_idx]
+    right_idx = xp.reshape(right_best, (-1, 1))
+    right = right[right_idx, all_idx]
+
+    # Reduce the rotation using the best indices
+    reduced = compose_quat(left, compose_quat(p, right))
+
+    if left is None:
+        left_best = None
+    if right is None:
+        right_best = None
+    return reduced, left_best, right_best
+
+
+def apply(quat: Array, points: Array, inverse: bool = False) -> Array:
+    xp = array_namespace(quat)
+    mat = as_matrix(quat)
+    # We do not have access to einsum. To avoid broadcasting issues, we add a singleton
+    # dimension to the points array and remove it after the operation.
+    points = points[..., None]
+    if not broadcastable(mat.shape, points.shape):
+        raise ValueError(
+            f"Cannot broadcast {quat.shape[:-1]} rotations to {points.shape[:-1]} "
+            "vectors."
+        )
+    if inverse:
+        # TODO: Replace with .mT once numpy 2.0 is the minimum supported version
+        return (xp.matrix_transpose(mat) @ points)[..., 0]
+    return (mat @ points)[..., 0]
+
+
+def setitem(
+    quat: Array, value: Array, indexer: int | slice | EllipsisType | None
+) -> Array:
+    return xpx.at(quat)[indexer, ...].set(value)
+
+
+def align_vectors(
+    a: Array, b: Array, weights: Array | None = None, return_sensitivity: bool = False
+) -> tuple[Array, Array, Array]:
+    xp = array_namespace(a)
+    # Check input vectors
+    dtype = xp_result_type(a, b, force_floating=True, xp=xp)
+    a_original = xp.asarray(a, dtype=dtype)
+    b_original = xp.asarray(b, dtype=dtype)
+    a = xpx.atleast_nd(a_original, ndim=2, xp=xp)
+    b = xpx.atleast_nd(b_original, ndim=2, xp=xp)
+    if a.shape[-1] != 3:
+        raise ValueError(
+            f"Expected input `a` to have shape (3,) or (N, 3), got {a_original.shape}"
+        )
+    if b.shape[-1] != 3:
+        raise ValueError(
+            f"Expected input `b` to have shape (3,) or (N, 3), got {b_original.shape}"
+        )
+    if a.shape != b.shape:
+        raise ValueError(
+            "Expected inputs `a` and `b` to have same shapes"
+            f", got {a_original.shape} and {b_original.shape} respectively."
+        )
+    if a.ndim > 2 or b.ndim > 2:  # This function does not support broadcasting
+        raise ValueError(
+            "Expected inputs `a` and `b` to have shape (3,) or (N, 3), got "
+            f"{a_original.shape} and {b_original.shape} respectively."
+        )
+    N = a.shape[0]
+
+    # Check weights
+    if weights is None:
+        weights = xp.ones(N, device=xp_device(a), dtype=a.dtype)
+    else:
+        weights = xp.asarray(weights, device=xp_device(a), dtype=a.dtype)
+        if weights.ndim != 1:
+            raise ValueError(
+                f"Expected `weights` to be 1 dimensional, got shape {weights.shape}."
+            )
+        if N > 1 and (weights.shape[0] != N):
+            raise ValueError(
+                "Expected `weights` to have number of values equal to number of input "
+                f"vectors, got {weights.shape[0]} values and {N} vectors."
+            )
+        # We can only check for negative weights in eager execution models. Lazy
+        # backends will return NaNs instead.
+        negative_weights = weights < 0
+        if not is_lazy_array(negative_weights) and xp.any(negative_weights):
+            raise ValueError("`weights` may not contain negative values")
+        weights = xp.where(negative_weights, xp.nan, weights)
+
+    # For the special case of a single vector pair, we use the infinite
+    # weight code path
+    weight_is_inf = xp.asarray([True]) if N == 1 else weights == xp.inf
+    n_inf = xp.sum(xp.astype(weight_is_inf, a.dtype))
+    # We can only error out on multiple infinite weights or sensitivity return with
+    # infinite weights in eager execution models. Lazy backends will return NaNs.
+    if not is_lazy_array(n_inf):
+        if n_inf > 1:
+            raise ValueError("Only one infinite weight is allowed")
+        if n_inf == 1 and return_sensitivity:
+            raise ValueError(
+                "Cannot return sensitivity matrix with an "
+                "infinite weight or one vector pair"
+            )
+
+    weights = xp.where(n_inf > 1, xp.nan, weights)
+
+    inf_branch = xp.any(weight_is_inf, axis=-1)
+    # DECISION: We cannot compute both branches for all frameworks. There are two main
+    # reasons:
+    # 1. Computing both for eager execution models is expensive.
+    # 2. Some operations will fail when running the unused branch because of numerical
+    # and algorithmical issues. Numpy e.g. will raise an exception when trying to
+    # compute the svd of a matrix with infinite weights. To prevent this, we only
+    # compute the branch that is needed. Lazy backends however require us to take the
+    # full compute graph. Therefore, we use xp.where for lazy backends and a branching
+    # version for eager frameworks.
+    #
+    # Note that we could also solve this by exploiting the externals of xpx.apply_where.
+    # However, we'd have to rely on the implementation details of apply_where, which is
+    # something we should avoid.
+    # See https://github.com/scipy/scipy/pull/22777#discussion_r2028868364
+    if is_lazy_array(inf_branch):
+        q_opt, rssd, sensitivity = _align_vectors(a, b, weights)
+        q_opt_inf, rssd_inf, sensitivity_inf = _align_vectors_fixed(a, b, weights)
+        q_opt = xp.where(inf_branch, q_opt_inf, q_opt)
+        rssd = xp.where(inf_branch, rssd_inf, rssd)
+        sensitivity = xp.where(inf_branch, sensitivity_inf, sensitivity)
+    else:
+        if xp.any(inf_branch):
+            q_opt, rssd, sensitivity = _align_vectors_fixed(a, b, weights)
+        else:
+            q_opt, rssd, sensitivity = _align_vectors(a, b, weights)
+    return q_opt, rssd, sensitivity
+
+
+def _align_vectors(a: Array, b: Array, weights: Array) -> tuple[Array, Array, Array]:
+    xp = array_namespace(a)
+    device = xp_device(a)
+    B = (weights[:, None] * a).mT @ b
+    u, s, vh = xp.linalg.svd(B)
+
+    # Correct improper rotation if necessary (as in Kabsch algorithm)
+    neg_det = xp.linalg.det(u @ vh) < 0
+    s = xpx.at(s)[..., -1].set(xp.where(neg_det, -s[..., -1], s[..., -1]))
+    u = xpx.at(u)[..., :, -1].set(xp.where(neg_det, -u[..., :, -1], u[..., :, -1]))
+
+    C = u @ vh
+
+    # DECISION: We cannot branch on the condition because jit code needs to be
+    # non-branching. Hence, we omit the check for uniqueness
+    # (s[1] + s[2] < 1e-16 * s[0])
+    ssd = xp.sum(weights * xp.sum(b**2 + a**2, axis=-1), axis=-1) - 2 * xp.sum(
+        s, axis=-1
+    )
+    rssd = xp.sqrt(xp.maximum(ssd, xp.zeros(1, device=device)))[..., 0]
+
+    # TODO: We currently need to always compute the sensitivity matrix because lazy code
+    # needs to be non-branching. We should check if compilers can optimize the where
+    # statement (e.g. in jax) and check if we can have an eager version that only
+    # evaluates the branch that is needed.
+    # See xpx.apply_where, issue: https://github.com/data-apis/array-api-extra/pull/141
+    zeta = (s[..., 0] + s[..., 1]) * (s[..., 1] + s[..., 2]) * (s[..., 2] + s[..., 0])
+    kappa = s[..., 0] * s[..., 1] + s[..., 1] * s[..., 2] + s[..., 2] * s[..., 0]
+    eye = xp.eye(3, dtype=a.dtype, device=device)
+    sensitivity = xp.mean(weights) / zeta * (kappa * eye + B @ B.mT)
+    q_opt = _from_matrix_orthogonal(C)
+    return q_opt, rssd, sensitivity
+
+
+def _align_vectors_fixed(
+    a: Array, b: Array, weights: Array
+) -> tuple[Array, Array, Array]:
+    xp = array_namespace(a)
+    device = xp_device(a)
+    N = a.shape[0]
+    weight_is_inf = xp.asarray([True], device=device) if N == 1 else weights == xp.inf
+    # We cannot use boolean masks for indexing because of jax. For the same reason, we
+    # also cannot use dynamic slices. As a workaround, we roll the array so that the
+    # infinitely weighted vector is at index 0. We then use static slices to get the
+    # primary and secondary vectors.
+    #
+    # Note that argmax fulfils a secondary purpose here:
+    # When we trace this function with jax, this function might get executed even if
+    # weight_is_inf does not have a single valid entry. Argmax will still give us a
+    # valid index which allows us to proceed with the function (the results are
+    # discarded anyways), whereas boolean indexing would result in invalid, zero-shaped
+    # arrays.
+
+    inf_idx = xp.argmax(xp.astype(weight_is_inf, xp.uint8))
+    # xp.argmax returns an Array, but the specification of xp.roll does not support
+    # Arrays as shifts. For lazy execution models we cannot convert to int because this
+    # raises a concretization error. However, jax does accept Arrays as shifts which
+    # allows jit compiling the function. Hence we do not convert to int for jax.
+    # See https://github.com/data-apis/array-api/issues/914#issuecomment-2918959918
+    if not is_jax(xp):
+        inf_idx = int(inf_idx)
+    a_sorted = xp.roll(a, shift=-inf_idx, axis=0)
+    b_sorted = xp.roll(b, shift=-inf_idx, axis=0)
+    weights_sorted = xp.roll(weights, shift=-inf_idx, axis=0)
+
+    a_pri = a_sorted[0, ...][None, ...]  # Effectively [[0], ...]
+    b_pri = b_sorted[0, ...][None, ...]
+    a_pri_norm = xp_vector_norm(a_pri, axis=-1, keepdims=True, xp=xp)
+    b_pri_norm = xp_vector_norm(b_pri, axis=-1, keepdims=True, xp=xp)
+    if not is_lazy_array(a_pri_norm):
+        if xp.any(a_pri_norm == 0) or xp.any(b_pri_norm == 0):
+            raise ValueError("Cannot align zero length primary vectors")
+
+    # We cannot error out on zero length vectors. We set the norm to NaN to avoid
+    # division by zero and mark the result as invalid.
+    a_pri_norm = xpx.at(a_pri_norm)[a_pri_norm == 0].set(xp.nan)
+    b_pri_norm = xpx.at(b_pri_norm)[b_pri_norm == 0].set(xp.nan)
+
+    a_pri = a_pri / a_pri_norm
+    b_pri = b_pri / b_pri_norm
+
+    # We first find the minimum angle rotation between the primary
+    # vectors.
+    cross = xp.linalg.cross(b_pri[..., 0, :], a_pri[..., 0, :])
+    cross_norm = xp_vector_norm(cross, axis=-1, xp=xp)
+    theta = xp.atan2(cross_norm, xp.sum(a_pri[..., 0, :] * b_pri[..., 0, :], axis=-1))
+    tolerance = 1e-3  # tolerance for small angle approximation (rad)
+    q_flip = xp.asarray([0.0, 0.0, 0.0, 1.0], dtype=a_pri.dtype, device=device)
+
+    # Near pi radians, the Taylor series approximation of x/sin(x) diverges, so for
+    # numerical stability we flip pi and then rotate back by the small angle pi - theta
+    flip = xp.pi - theta < tolerance
+    # For antiparallel vectors, cross = [0, 0, 0] so we need to manually set an
+    # arbitrary orthogonal axis of rotation
+    i = xp.argmin(xp.abs(a_pri[..., 0, :]))
+    # TODO: Array API does not support fancy indexing __setitem__. The code is
+    # equivalent to doing the following:
+    # r_components = xp.zeros(3)
+    # r_components = xpx.at(r_components)[i - 1].set(a_pri[0, i - 2])
+    # r_components = xpx.at(r_components)[i - 2].set(-a_pri[0, i - 1])
+    r_components = xp.stack(
+        [
+            xp.where(i == 1, a_pri[0, 2], xp.where(i == 2, -a_pri[0, 1], 0)),
+            xp.where(i == 2, a_pri[0, 0], xp.where(i == 0, -a_pri[0, 2], 0)),
+            xp.where(i == 0, a_pri[0, 1], xp.where(i == 1, -a_pri[0, 0], 0)),
+        ]
+    )
+    r = xp.where(cross_norm == 0, r_components, cross)
+
+    q_flip = xp.where(flip, from_rotvec(r / xp_vector_norm(r, xp=xp) * xp.pi), q_flip)
+    theta = xp.where(flip, xp.pi - theta, theta)
+    cross = xp.where(flip, -cross, cross)
+
+    # Small angle Taylor series approximation for numerical stability
+    theta2 = theta * theta
+    small_scale = xp.abs(theta) < tolerance
+    r_small_scale = cross * (1 + theta2 / 6 + theta2 * theta2 * 7 / 360)
+    # We need to handle the case where theta is 0 to avoid division by zero. We use the
+    # value of the Taylor series approximation, but non-branching operations require
+    # that we still divide by the angle. Since we do not use the result where the angle
+    # is close to 0, this is safe.
+    theta = theta + xp.asarray(small_scale, dtype=theta.dtype)
+    r_large_scale = cross * theta / xp.sin(theta)
+    r = xp.where(small_scale, r_small_scale, r_large_scale)
+    q_pri = compose_quat(from_rotvec(r), q_flip)
+
+    # Case 1): No secondary vectors, q_opt is q_pri -> Immediately done
+    # Case 2): Secondary vectors exist
+    # We cannot use boolean masks here because of jax
+    a_sec = a_sorted[1:, ...]
+    b_sec = b_sorted[1:, ...]
+    weights_sec = weights_sorted[1:]
+
+    # We apply the first rotation to the b vectors to align the
+    # primary vectors, resulting in vectors c. The secondary
+    # vectors must now be rotated about that primary vector to best
+    # align c to a.
+    c_sec = apply(q_pri, b_sec)
+
+    # Calculate vector components for the angle calculation. The
+    # angle phi to rotate a single 2D vector C to align to 2D
+    # vector A in the xy plane can be found with the equation
+    # phi = atan2(cross(C, A), dot(C, A))
+    #     = atan2(|C|*|A|*sin(phi), |C|*|A|*cos(phi))
+    # The below equations perform the same operation, but with the
+    # 3D rotation restricted to the 2D plane normal to a_pri, where
+    # the secondary vectors are projected into that plane. We then
+    # find the composite angle from the weighted sum of the
+    # axial components in that plane, minimizing the 2D alignment
+    # problem.
+    sin_term = xp.linalg.vecdot(xp.linalg.cross(c_sec, a_sec), a_pri)
+    cos_term = xp.linalg.vecdot(c_sec, a_sec) - (
+        xp.linalg.vecdot(c_sec, a_pri) * xp.linalg.vecdot(a_sec, a_pri)
+    )
+    phi = xp.atan2(xp.sum(weights_sec * sin_term), xp.sum(weights_sec * cos_term))
+    q_sec = from_rotvec(phi * a_pri[0, ...])
+
+    # Compose these to get the optimal rotation
+    q_opt = q_pri if N == 1 else compose_quat(q_sec, q_pri)
+
+    # Calculate the root sum squared distance. We force the error to
+    # be zero for the infinite weight vectors since they will align
+    # exactly.
+    mask = ((N > 1) | (weights[0] == xp.inf)) & weight_is_inf
+    # Skip non-infinite weight single vectors pairs, we used the
+    # infinite weight code path but don't want to zero that weight
+    weights_inf_zero = xpx.at(weights, mask).set(0, copy=True, xp=xp)
+    a_est = apply(q_opt, b)
+    rssd = xp.sqrt(xp.sum(weights_inf_zero @ (a - a_est) ** 2))
+
+    mask = xp.any(xp.isnan(weights), axis=-1)
+    q_opt = xp.where(mask, xp.nan, q_opt)
+    return q_opt, rssd, xp.asarray(xp.nan, device=device)
+
+
+def pow(quat: Array, n: float | Array) -> Array:
+    xp = array_namespace(quat)
+    device = xp_device(quat)
+    # If n is an array, we sanitize it to a scalar and promote quat and n to
+    # the same dtype.
+    if is_array_api_obj(n):
+        if n.shape == (1,):  # pyrefly:ignore[missing-attribute]
+            n = n[0]  # pyrefly:ignore[bad-index]
+        elif n.ndim != 0:  # pyrefly:ignore[missing-attribute]
+            raise ValueError("Array exponent must be a scalar")
+        quat, n = xp_promote(quat, n, force_floating=True, xp=xp)
+
+    # If n is a lazy array, we cannot take fast paths for special cases.
+    if is_lazy_array(n):
+        result = from_rotvec(n * as_rotvec(quat))  # general scaling of rotation angle
+        # Special cases 0 -> identity, -1 -> inv, 1 -> copy
+        identity = xp.zeros((*quat.shape[:-1], 4), dtype=quat.dtype, device=device)
+        identity = xpx.at(identity)[..., 3].set(1)
+        result = xp.where(n == 0, identity, result)
+        result = xp.where(n == -1, inv(quat), result)
+        result = xp.where(n == 1, quat, result)
+        return result
+    if n == 0:
+        identity = xp.zeros((*quat.shape[:-1], 4), dtype=quat.dtype, device=device)
+        return xpx.at(identity)[..., 3].set(1)
+    if n == -1:
+        return inv(quat)
+    if n == 1:
+        return quat
+    return from_rotvec(n * as_rotvec(quat))
+
+
+def _normalize_quaternion(quat: Array) -> Array:
+    xp = array_namespace(quat)
+    quat_norm = xp_vector_norm(quat, axis=-1, keepdims=True, xp=xp)
+    zero_norm = quat_norm == 0
+    if is_lazy_array(quat_norm):
+        quat = xp.where(zero_norm, xp.nan, quat)
+    elif xp.any(zero_norm):
+        raise ValueError("Found zero norm quaternions in `quat`.")
+    return quat / quat_norm
+
+
+def _quat_canonical(quat: Array) -> Array:
+    xp = array_namespace(quat)
+    mask = quat[..., 3] < 0
+    zero_w = quat[..., 3] == 0
+    mask = mask | (zero_w & (quat[..., 0] < 0))
+    zero_wx = zero_w & (quat[..., 0] == 0)
+    mask = mask | (zero_wx & (quat[..., 1] < 0))
+    zero_wxy = zero_wx & (quat[..., 1] == 0)
+    mask = mask | (zero_wxy & (quat[..., 2] < 0))
+    return xp.where(mask[..., None], -quat, quat)
+
+
+def _elementary_basis_index(axis: str) -> int:
+    if axis == "x":
+        return 0
+    elif axis == "y":
+        return 1
+    elif axis == "z":
+        return 2
+    raise ValueError(f"Expected axis to be from ['x', 'y', 'z'], got {axis}")
+
+
+def _compute_davenport_from_quat(
+    quat: Array,
+    n1: Array,
+    n2: Array,
+    n3: Array,
+    extrinsic: bool,
+    suppress_warnings: bool,
+) -> Array:
+    # The algorithm assumes extrinsic frame transformations. The algorithm
+    # in the paper is formulated for rotation quaternions, which are stored
+    # directly by Rotation.
+    # Adapt the algorithm for our case by reversing both axis sequence and
+    # angles for intrinsic rotations when needed
+    xp = array_namespace(quat)
+    n1, n3 = (n1, n3) if extrinsic else (n3, n1)
+
+    n_cross = xp.linalg.cross(n1, n2)
+    lamb = xp.atan2(xp.vecdot(n3, n_cross), xp.vecdot(n3, n1))
+
+    # alternative set of angles compatible with as_euler implementation
+    mask = lamb < 0
+    n2 = xp.where(mask[..., None], -n2, n2)
+    lamb = xp.where(mask, -lamb, lamb)
+    n_cross = xp.where(mask[..., None], -n_cross, n_cross)
+    correct_set = mask
+
+    quat_lamb = xp.concat(
+        (xp.sin(lamb / 2)[..., None] * n2, xp.cos(lamb / 2)[..., None]), axis=-1
+    )
+
+    q_trans = compose_quat(quat_lamb, quat)
+    a = q_trans[..., 3]
+    b = xp.linalg.vecdot(q_trans[..., :3], n1)
+    c = xp.linalg.vecdot(q_trans[..., :3], n2)
+    d = xp.linalg.vecdot(q_trans[..., :3], n_cross)
+
+    angles = _get_angles(extrinsic, False, 1, lamb, a, b, c, d, suppress_warnings)
+    angles = xpx.at(angles)[..., 1].set(
+        xp.where(correct_set, -angles[..., 1], angles[..., 1])
+    )
+
+    return angles
+
+
+def _elementary_quat_compose(axes: list[int], angles: Array, intrinsic: bool) -> Array:
+    xp = array_namespace(angles)
+    device = xp_device(angles)
+    quat = _make_elementary_quat(axes[0], angles[..., 0], device=device, xp=xp)
+    for i in range(1, len(axes)):
+        ax_quat = _make_elementary_quat(axes[i], angles[..., i], device=device, xp=xp)
+        quat = compose_quat(quat, ax_quat) if intrinsic else compose_quat(ax_quat, quat)
+    return quat
+
+
+def _make_elementary_quat(axis: int, angle: Array, device, xp) -> Array:
+    quat = xp.zeros((*angle.shape, 4), dtype=angle.dtype, device=device)
+    quat = xpx.at(quat)[..., 3].set(xp.cos(angle / 2.0))
+    quat = xpx.at(quat)[..., axis].set(xp.sin(angle / 2.0))
+    return quat
+
+
+def _get_angles(
+    extrinsic: bool,
+    symmetric: bool,
+    sign: int,
+    lamb: float,
+    a: Array,
+    b: Array,
+    c: Array,
+    d: Array,
+    suppress_warnings: bool,
+) -> Array:
+    xp = array_namespace(a)
+    device = xp_device(a)
+    eps = 1e-7
+    half_sum = xp.atan2(b, a)
+    half_diff = xp.atan2(d, c)
+    # We zero-initialize to automatically cover singular cases where the second angle is
+    # not defined uniquely.
+    angles = xp.zeros((*a.shape, 3), dtype=a.dtype, device=device)
+
+    angles = xpx.at(angles)[..., 1].set(2 * xp.atan2(xp.hypot(c, d), xp.hypot(a, b)))
+
+    angle_first = 0 if extrinsic else 2
+    angle_third = 2 if extrinsic else 0
+
+    # Check if the second angle is close to 0 or pi, causing a singularity.
+    # - Case 0: Second angle is neither close to 0 nor pi.
+    # - Case 1: Second angle is close to 0.
+    # - Case 2: Second angle is close to pi.
+    case1 = xp.abs(angles[..., 1]) <= eps
+    case2 = xp.abs(angles[..., 1] - xp.pi) <= eps
+    case0 = ~(case1 | case2)
+    if not suppress_warnings and not is_lazy_array(case0) and xp.any(~case0):
+        warnings.warn(
+            "Gimbal lock detected. Setting third angle to zero "
+            "since it is not possible to uniquely determine "
+            "all angles.",
+            stacklevel=3,
+        )
+
+    # This writes case1 into a0 where True and case2 everywhere else. This is sound
+    # because we later overwrite any values without singularity with the regular value
+    # of case0. The second angle is covered by default since we zero-initialized the
+    # second dimension.
+    a0 = xp.where(case1, 2 * half_sum, 2 * half_diff * (-1 if extrinsic else 1))
+    angles = xpx.at(angles)[..., 0].set(a0)
+
+    # We overwrite the values of angles without singularities (case0)
+    a1 = xp.where(case0, half_sum - half_diff, angles[..., angle_first])
+    angles = xpx.at(angles)[..., angle_first].set(a1)
+
+    # Same as above but for the third angle. We overwrite the non-singular case0 values
+    a3 = xp.where(case0, half_sum + half_diff, angles[..., angle_third])
+    if not symmetric:
+        a3 = a3 * sign
+        angles = xpx.at(angles)[..., 1].set(angles[..., 1] - lamb)
+    angles = xpx.at(angles)[..., angle_third].set(a3)
+
+    angles = (angles + xp.pi) % (2 * xp.pi) - xp.pi
+    return angles
+
+
+def compose_quat(p: Array, q: Array) -> Array:
+    xp = array_namespace(p)
+    cross = xp.linalg.cross(p[..., :3], q[..., :3])
+    qx = p[..., 3] * q[..., 0] + q[..., 3] * p[..., 0] + cross[..., 0]
+    qy = p[..., 3] * q[..., 1] + q[..., 3] * p[..., 1] + cross[..., 1]
+    qz = p[..., 3] * q[..., 2] + q[..., 3] * p[..., 2] + cross[..., 2]
+    qw = (
+        p[..., 3] * q[..., 3]
+        - p[..., 0] * q[..., 0]
+        - p[..., 1] * q[..., 1]
+        - p[..., 2] * q[..., 2]
+    )
+    quat = xp.stack([qx, qy, qz, qw], axis=-1)
+    return quat
+
+
+def _split_rotation(q: Array, xp) -> tuple[Array, Array]:
+    q = xpx.atleast_nd(q, ndim=2, xp=xp)
+    return q[..., -1], q[..., :-1]
+
+
+def _deg2rad(angles: Array) -> Array:
+    return angles * (np.pi / 180.0)
+
+
+def _rad2deg(angles: Array) -> Array:
+    return angles * (180.0 / np.pi)

v12x/pylib/scipy/spatial/transform/rotation.py

@@ -0,0 +1,21 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.spatial` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+__all__ = [  # noqa: F822
+    'Rotation',
+    'Slerp',
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="spatial.transform", module="rotation",
+                                   private_modules=["_rotation"], all=__all__,
+                                   attribute=name)

v12x/pylib/scipy/spatial/transform/tests/test_rigid_transform.py

@@ -0,0 +1,1531 @@
+import pickle
+from itertools import product
+
+import pytest
+
+import numpy as np
+from scipy.spatial.transform import Rotation, RigidTransform
+from scipy.spatial.transform._rigid_transform import normalize_dual_quaternion
+from scipy._lib._array_api import (
+    is_lazy_array,
+    xp_vector_norm,
+    is_numpy,
+    xp_assert_close,
+    make_xp_test_case,
+    xp_assert_equal,
+    xp_promote
+)
+import scipy._external.array_api_extra as xpx
+
+
+def rotation_to_xp(r: Rotation, xp):
+    dtype = xpx.default_dtype(xp)
+    return Rotation.from_quat(xp.asarray(r.as_quat(), dtype=dtype))
+
+
+def rigid_transform_to_xp(r: RigidTransform, xp):
+    dtype = xpx.default_dtype(xp)
+    return RigidTransform.from_matrix(xp.asarray(r.as_matrix(), dtype=dtype))
+
+
+@make_xp_test_case((RigidTransform, "as_matrix"))
+def test_repr(xp):
+    actual = repr(RigidTransform.from_matrix(xp.eye(4)))
+    expected = """\
+RigidTransform.from_matrix(array([[1., 0., 0., 0.],
+                                  [0., 1., 0., 0.],
+                                  [0., 0., 1., 0.],
+                                  [0., 0., 0., 1.]]))"""
+    if is_numpy(xp):
+        assert actual == expected
+    else:
+        assert actual.startswith("RigidTransform.from_matrix(")
+
+    tf = RigidTransform.from_matrix(xp.asarray(RigidTransform.identity(2).as_matrix()))
+    actual = repr(tf)
+    expected = """\
+RigidTransform.from_matrix(array([[[1., 0., 0., 0.],
+                                   [0., 1., 0., 0.],
+                                   [0., 0., 1., 0.],
+                                   [0., 0., 0., 1.]],
+                           
+                                  [[1., 0., 0., 0.],
+                                   [0., 1., 0., 0.],
+                                   [0., 0., 1., 0.],
+                                   [0., 0., 0., 1.]]]))"""
+    if is_numpy(xp):
+        assert actual == expected
+    else:
+        assert actual.startswith("RigidTransform.from_matrix(")
+
+
+@make_xp_test_case((RigidTransform, "from_rotation"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_from_rotation(xp, ndim: int):
+    atol = 1e-12
+    rng = np.random.default_rng(0)
+    shape = (ndim,) * (ndim - 1) + (4,)
+    r = rotation_to_xp(Rotation.from_quat(rng.normal(size=shape)), xp=xp)
+    tf = RigidTransform.from_rotation(r)
+    xp_assert_close(tf.as_matrix()[..., :3, :3], r.as_matrix(), atol=atol)
+    xp_assert_close(tf.as_matrix()[..., :3, 3], xp.zeros(shape[:-1] + (3,)), atol=atol)
+    xp_assert_close(tf.as_matrix()[..., 3, :3], xp.zeros(shape[:-1] + (3,)), atol=atol)
+    xp_assert_close(tf.as_matrix()[..., 3, 3], xp.ones(shape[:-1]), atol=atol)
+    assert tf.single == (ndim == 1)
+
+
+@make_xp_test_case((RigidTransform, "from_translation"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_from_translation(xp, ndim: int):
+    shape = (ndim,) * (ndim - 1)
+    t = xp.reshape(xp.arange(ndim ** (ndim-1) * 3), shape + (3,))
+    tf = RigidTransform.from_translation(t)
+
+    expected = xp.tile(xp.eye(4), shape + (1, 1))
+    t_float = xp_promote(t, force_floating=True, xp=xp)
+    expected = xpx.at(expected)[..., :3, 3].set(t_float)
+    xp_assert_close(tf.as_matrix(), expected)
+    assert tf.single == (ndim == 1)
+
+
+def test_from_translation_array_like():
+    # Test single translation
+    t = [1, 2, 3]
+    tf = RigidTransform.from_translation(t)
+    tf_expected = RigidTransform.from_translation(np.array(t))
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix())
+    assert tf.single
+
+    # Test multiple translations
+    t = [[1, 2, 3], [4, 5, 6]]
+    tf = RigidTransform.from_translation(t)
+    tf_expected = RigidTransform.from_translation(np.array(t))
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix())
+    assert not tf.single
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"), (RigidTransform, "as_matrix"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_from_matrix(xp, ndim: int):
+    atol = 1e-12
+    shape = (ndim,) * (ndim - 1) + (4, 4)
+    dtype = xpx.default_dtype(xp)
+
+    matrix = xp.tile(xp.eye(4), shape[:-2] + (1, 1))
+    t = xp.reshape(xp.arange(ndim ** (ndim-1) * 3, dtype=dtype), shape[:-2] + (3,))
+    matrix = xpx.at(matrix)[..., :3, 3].set(t)
+
+    tf = RigidTransform.from_matrix(matrix)
+    xp_assert_close(tf.as_matrix(), matrix, atol=atol)
+    assert tf.single == (ndim == 1)
+
+    # Test non-1 determinant
+    matrix = xp.tile(xp.eye(4), shape[:-2] + (1, 1))
+    matrix = xpx.at(matrix)[..., :3, :3].set(xp.eye(3) * 2.0)
+    tf = RigidTransform.from_matrix(matrix)
+    expected = xp.tile(xp.eye(4), shape[:-2] + (1, 1))
+    xp_assert_close(tf.as_matrix(), expected, atol=atol)
+
+    # Test non-orthogonal rotation matrix
+    matrix = xp.tile(xp.eye(4), shape[:-2] + (1, 1))
+    # matrix is equivalent to [[1, 1, 0, 0],
+    #                          [0, 1, 0, 0],
+    #                          [0, 0, 1, 0],
+    #                          [0, 0, 0, 1]]
+    matrix = xpx.at(matrix)[..., 0, 1].set(1.0)
+    tf = RigidTransform.from_matrix(matrix)
+    expected = xp.tile(xp.eye(4), shape[:-2] + (1, 1))
+    expected = xpx.at(expected)[..., 0, 0].set(0.894427)
+    expected = xpx.at(expected)[..., 0, 1].set(0.447214)
+    expected = xpx.at(expected)[..., 1, 0].set(-0.447214)
+    expected = xpx.at(expected)[..., 1, 1].set(0.894427)
+    xp_assert_close(tf.as_matrix(), expected, atol=1e-6)
+
+    # Test invalid matrix
+    invalid = xp.tile(xp.eye(4), shape[:-2] + (1, 1))
+    invalid = xpx.at(invalid)[..., 3, 3].set(2)  # Invalid last row
+    if is_lazy_array(invalid):
+        tf = RigidTransform.from_matrix(invalid)
+        assert xp.all(xp.isnan(tf.as_matrix()))
+    else:
+        with pytest.raises(ValueError):
+            RigidTransform.from_matrix(invalid)
+
+
+def test_from_matrix_array_like():
+    # Test single transform matrix
+    matrix = [[1, 0, 0, 0],
+              [0, 1, 0, 0],
+              [0, 0, 1, 0],
+              [0, 0, 0, 1]]
+    expected = np.eye(4)
+    tf = RigidTransform.from_matrix(matrix)
+    xp_assert_close(tf.as_matrix(), expected)
+    assert tf.single
+
+    # Test multiple transform matrices
+    matrices = [matrix, matrix]
+    tf = RigidTransform.from_matrix(matrices)
+    for i in range(len(matrices)):
+        xp_assert_close(tf.as_matrix()[i, ...], expected)
+    assert not tf.single
+
+
+@make_xp_test_case((RigidTransform, "from_components"))
+@pytest.mark.parametrize("r_ndim", range(1, 3))
+@pytest.mark.parametrize("t_ndim", range(1, 3))
+def test_from_components(xp, r_ndim: int, t_ndim: int):
+    atol = 1e-12
+    dims = (6, 5, 4, 3)  # Common shape
+    q_shape = dims[:r_ndim - 1][::-1] + (4,)
+    t_shape = dims[:t_ndim - 1][::-1] + (3,)
+    tf_shape = np.broadcast_shapes(q_shape[:-1], t_shape[:-1]) + (4, 4)
+    rng = np.random.default_rng(0)
+
+    t = xp.reshape(xp.arange(np.prod(t_shape[:-1]) * 3), t_shape)
+    r = rotation_to_xp(Rotation.from_quat(rng.random(size=q_shape)), xp=xp)
+    tf = RigidTransform.from_components(t, r)
+
+    expected = xp.zeros(tf_shape)
+    expected = xpx.at(expected)[..., :3, :3].set(r.as_matrix())
+    t_float = xp_promote(t, force_floating=True, xp=xp)
+    expected = xpx.at(expected)[..., :3, 3].set(t_float)
+    expected = xpx.at(expected)[..., 3, 3].set(1)
+    xp_assert_close(tf.as_matrix(), expected, atol=atol)
+    assert tf.single == (r_ndim == 1 and t_ndim == 1)
+
+
+def test_from_components_array_like():
+    rng = np.random.default_rng(123)
+    # Test single rotation and translation
+    t = [1, 2, 3]
+    r = Rotation.random(rng=rng)
+    tf = RigidTransform.from_components(t, r)
+    tf_expected = RigidTransform.from_components(np.array(t), r)
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix(), atol=1e-12)
+    assert tf.single
+
+    # Test multiple rotations and translations
+    t = [[1, 2, 3], [4, 5, 6]]
+    r = Rotation.random(len(t), rng=rng)
+    tf = RigidTransform.from_components(t, r)
+    tf_expected = RigidTransform.from_components(np.array(t), r)
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix(), atol=1e-12)
+    assert not tf.single
+
+
+@make_xp_test_case((RigidTransform, "as_components"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_as_components(xp, ndim):
+    dtype = xpx.default_dtype(xp)
+    atol = 1e-12 if dtype == xp.float64 else 1e-6
+    shape = (ndim,) * (ndim - 1)
+    rng = np.random.default_rng(123)
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    r = rotation_to_xp(Rotation.from_quat(rng.random(shape + (4,))), xp=xp)
+    tf = RigidTransform.from_components(t, r)
+    new_t, new_r = tf.as_components()
+    assert xp.all(new_r.approx_equal(r, atol=atol))
+    xp_assert_close(new_t, t, atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "from_exp_coords"))
+@pytest.mark.parametrize("dim", range(1, 4))
+def test_from_exp_coords(xp, dim: int):
+    shape = (dim,) * (dim - 1)
+    # example from 3.3 of
+    # https://hades.mech.northwestern.edu/images/2/25/MR-v2.pdf
+    dtype = xpx.default_dtype(xp)
+    angle1 = np.deg2rad(30.0)
+    mat = xp.asarray([
+        [np.cos(angle1), -np.sin(angle1), 0.0, 1.0],
+        [np.sin(angle1), np.cos(angle1), 0.0, 2.0],
+        [0.0, 0.0, 1.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0]
+    ], dtype=dtype)
+    mat = xp.tile(mat, shape + (1, 1))
+    tf1 = RigidTransform.from_matrix(mat)
+    angle2 = np.deg2rad(60.0)
+    mat = xp.asarray([
+        [np.cos(angle2), -np.sin(angle2), 0.0, 2.0],
+        [np.sin(angle2), np.cos(angle2), 0.0, 1.0],
+        [0.0, 0.0, 1.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0]
+    ], dtype=dtype)
+    mat = xp.tile(mat, shape + (1, 1))
+    tf2 = RigidTransform.from_matrix(mat)
+    expected = tf2 * tf1.inv()
+    deg2rag = xp.asarray(np.deg2rad(30.0))
+    exp_coords = deg2rag * xp.asarray([0.0, 0.0, 1.0, 3.37, -3.37, 0.0])
+    exp_coords = xp.tile(exp_coords, shape + (1,))
+    actual = RigidTransform.from_exp_coords(exp_coords)
+    xp_assert_close(actual.as_matrix(), expected.as_matrix(), atol=1e-2)
+
+    # test cases generated by comparison to pytransform3d
+    exp_coords = xp.asarray([
+        [-2.01041204, -0.52983629, 0.65773501,
+         0.10386614, 0.05855009, 0.54959179],
+        [-0.22537438, -0.24132627, -2.4747121,
+         -0.09158594,  1.88075832, -0.03197204]
+    ])
+    exp_coords = xp.tile(exp_coords, shape + (1,))
+    expected_matrix = xp.asarray([
+        [[0.76406621, 0.10504613, -0.63652819, -0.10209961],
+         [0.59956454, -0.47987325, 0.64050295, 0.40158789],
+         [-0.2381705, -0.87102639, -0.42963687, 0.19637636],
+         [0., 0., 0., 1.]],
+        [[-0.78446989, 0.61157488, 0.10287448, 1.33330055],
+         [-0.58017785, -0.78232107, 0.22664378, 0.52660831],
+         [0.21909052, 0.11810973, 0.96852952, -0.02968529],
+         [0., 0., 0., 1.]]
+    ])
+    expected_matrix = xp.tile(expected_matrix, shape + (1, 1))
+    xp_assert_close(
+        RigidTransform.from_exp_coords(exp_coords).as_matrix(),
+        expected_matrix, atol=1e-8)
+
+    # identity
+    expected_matrix = xp.tile(xp.eye(4), shape + (1, 1))
+    exp_coords = xp.zeros(shape + (6,), dtype=dtype)
+    xp_assert_close(
+        RigidTransform.from_exp_coords(exp_coords).as_matrix(),
+        expected_matrix, atol=1e-12)
+
+    # only translation
+    expected_matrix = xp.asarray([
+        [[1.0, 0.0, 0.0, 3.0],
+         [0.0, 1.0, 0.0, -5.4],
+         [0.0, 0.0, 1.0, 100.2],
+         [0.0, 0.0, 0.0, 1.0]],
+        [[1.0, 0.0, 0.0, -3.0],
+         [0.0, 1.0, 0.0, 13.3],
+         [0.0, 0.0, 1.0, 1.3],
+         [0.0, 0.0, 0.0, 1.0]]
+    ])
+    expected_matrix = xp.tile(expected_matrix, shape + (1, 1, 1))
+    exp_coords = xp.asarray([
+        [0.0, 0.0, 0.0, 3.0, -5.4, 100.2],
+        [0.0, 0.0, 0.0, -3.0, 13.3, 1.3],
+    ])
+    exp_coords = xp.tile(exp_coords, shape + (1, 1))
+    actual = RigidTransform.from_exp_coords(exp_coords)
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=1e-12)
+
+    # only rotation
+    angles = xp.asarray([[34, -12, 0.5], [-102, -55, 30]])
+    angles = xp.tile(angles, shape + (1, 1))
+    rot = Rotation.from_euler('zyx', angles, degrees=True)
+    rotvec = rot.as_rotvec()
+    expected_matrix = xp.tile(xp.eye(4), shape + (2, 1, 1))
+    expected_matrix = xpx.at(expected_matrix)[..., :3, :3].set(rot.as_matrix())
+    exp_coords = xp.concat((rotvec, xp.zeros_like(rotvec)), axis=-1)
+    actual = RigidTransform.from_exp_coords(exp_coords)
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=1e-12)
+
+
+def test_from_exp_coords_array_like():
+    rng = np.random.default_rng(123)
+    # Test single transform
+    t = np.array([1, 2, 3])
+    r = Rotation.random(rng=rng)
+    tf_expected = RigidTransform.from_components(t, r)
+    exp_coords = tf_expected.as_exp_coords().tolist()
+    assert isinstance(exp_coords, list)
+    tf = RigidTransform.from_exp_coords(exp_coords)
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix(), atol=1e-12)
+
+    # Test multiple transforms
+    t = [[1, 2, 3], [4, 5, 6]]
+    r = Rotation.random(len(t), rng=rng)
+    tf_expected = RigidTransform.from_components(t, r)
+    exp_coords = tf_expected.as_exp_coords().tolist()
+    assert isinstance(exp_coords, list)
+    tf = RigidTransform.from_exp_coords(exp_coords)
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix(), atol=1e-12)
+
+
+@make_xp_test_case((RigidTransform, "as_exp_coords"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_as_exp_coords(xp, ndim: int):
+    shape = (ndim,) * (ndim - 1)
+    # identity
+    expected = xp.zeros(shape + (6,))
+    actual = RigidTransform.from_exp_coords(expected).as_exp_coords()
+    xp_assert_close(actual, expected, atol=1e-12)
+
+    rng = np.random.default_rng(10)
+
+    # pure rotation
+    rot_vec = xp.asarray(rng.normal(scale=0.1, size=shape + (1000, 3)))
+    tf = RigidTransform.from_rotation(Rotation.from_rotvec(rot_vec))
+    exp_coords = tf.as_exp_coords()
+    xp_assert_close(exp_coords[..., :3], rot_vec, atol=1e-12)
+    expected = xp.zeros_like(rot_vec)
+    xp_assert_close(exp_coords[..., 3:], expected, atol=1e-16)
+
+    # pure translation
+    translation = xp.asarray(rng.normal(scale=100.0, size=shape + (1000, 3)))
+    tf = RigidTransform.from_translation(translation)
+    exp_coords = tf.as_exp_coords()
+    xp_assert_close(exp_coords[..., :3], expected, atol=1e-16)
+    xp_assert_close(exp_coords[..., 3:], translation, atol=1e-15)
+
+
+@make_xp_test_case((RigidTransform, "from_dual_quat"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_from_dual_quat(xp, ndim: int):
+    dtype = xpx.default_dtype(xp)
+    atol = 1e-12 if dtype == xp.float64 else 1e-7
+    shape = (ndim,) * (ndim - 1)
+
+    # identity
+    dq = xp.asarray([0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], dtype=dtype)
+    dq = xp.tile(dq, shape + (1,))
+    expected = xp.tile(xp.eye(4), shape + (1, 1))
+    xp_assert_close(RigidTransform.from_dual_quat(dq).as_matrix(), expected, atol=atol)
+    dq = xp.asarray([1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=dtype)
+    dq = xp.tile(dq, shape + (1,))
+    xp_assert_close(RigidTransform.from_dual_quat(dq, scalar_first=True).as_matrix(),
+                    expected, atol=atol)
+
+    # only translation
+    dq = xp.asarray([0, 0, 0, 1, 0.25, 0.15, -0.7, 0], dtype=dtype)
+    dq = xp.tile(dq, shape + (1,))
+    actual = RigidTransform.from_dual_quat(dq)
+    expected_matrix = xp.asarray([
+        [1, 0, 0, 0.5],
+        [0, 1, 0, 0.3],
+        [0, 0, 1, -1.4],
+        [0, 0, 0, 1]
+    ])
+    expected_matrix = xp.tile(expected_matrix, shape + (1, 1))
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=atol)
+    dq = xp.asarray([1, 0, 0, 0, 0, 0.25, 0.15, -0.7], dtype=dtype)
+    dq = xp.tile(dq, shape + (1,))
+    actual = RigidTransform.from_dual_quat(dq, scalar_first=True)
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=atol)
+
+    # only rotation
+    angles = xp.asarray([65, -13, 90], dtype=dtype)
+    angles = xp.tile(angles, shape + (1,))
+    actual_rot = Rotation.from_euler("xyz", angles, degrees=True)
+    qrot = actual_rot.as_quat()
+    dq = xp.concat((qrot, xp.zeros_like(qrot)), axis=-1)
+    actual = RigidTransform.from_dual_quat(dq)
+    expected_matrix = xp.tile(xp.eye(4), shape + (1, 1))
+    expected_matrix = xpx.at(expected_matrix)[..., :3, :3].set(actual_rot.as_matrix())
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=atol)
+
+    qrot = actual_rot.as_quat(scalar_first=True)
+    dq = xp.concat((qrot, xp.zeros_like(qrot)), axis=-1)
+    actual = RigidTransform.from_dual_quat(dq, scalar_first=True)
+    expected_matrix = xp.tile(xp.eye(4), shape + (1, 1))
+    expected_matrix = xpx.at(expected_matrix)[..., :3, :3].set(actual_rot.as_matrix())
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=atol)
+
+    # rotation and translation
+    # rtol is set to 1e-7 because xp_assert_close deviates from
+    # np.testing.assert_allclose in that it does not automatically default to 1e-7 for
+    # floating point inputs.
+    # See https://numpy.org/doc/2.2/reference/generated/numpy.testing.assert_allclose.html
+    dq = xp.asarray(
+        [[0.0617101, -0.06483886, 0.31432811, 0.94508498,
+          0.04985168, -0.26119618, 0.1691491, -0.07743254],
+         [0.19507259, 0.49404931, -0.06091285, 0.8450749,
+          0.65049656, -0.30782513, 0.16566752, 0.04174544]])
+    dq = xp.tile(dq, shape + (1, 1))
+    actual = RigidTransform.from_dual_quat(dq)
+    expected_matrix = xp.asarray(
+        [[[0.79398752, -0.60213598, -0.08376202, 0.24605262],
+          [0.58613113, 0.79477941, -0.15740392, -0.4932833],
+          [0.16135089, 0.07588122, 0.98397557, 0.34262676],
+          [0., 0., 0., 1.]],
+         [[0.50440981, 0.2957028, 0.81125249, 1.20934468],
+          [0.08979911, 0.91647262, -0.3898898, -0.70540077],
+          [-0.8587822, 0.26951399, 0.43572393, -0.47776265],
+          [0., 0., 0., 1.]]])
+    expected_matrix = xp.tile(expected_matrix, shape + (1, 1, 1))
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=atol, rtol=1e-7)
+
+    dq = xp.asarray(
+        [[0.94508498, 0.0617101, -0.06483886, 0.31432811,
+          -0.07743254, 0.04985168, -0.26119618, 0.1691491],
+         [0.8450749, 0.19507259, 0.49404931, -0.06091285,
+          0.04174544, 0.65049656, -0.30782513, 0.16566752]])
+    dq = xp.tile(dq, shape + (1, 1))
+    actual = RigidTransform.from_dual_quat(dq, scalar_first=True)
+    xp_assert_close(actual.as_matrix(), expected_matrix, atol=atol, rtol=1e-7)
+
+    # unnormalized dual quaternions
+
+    # invalid real quaternion with norm 0
+    dq = xp.zeros(shape + (8,))
+    actual = RigidTransform.from_dual_quat(dq)
+    expected = xp.tile(xp.eye(4), shape + (1, 1))
+    xp_assert_close(actual.as_matrix(), expected, atol=atol)
+
+    # real quaternion with norm != 1
+    unnormalized_dual_quat = xp.asarray(
+        [-0.2547655, 1.23506123, 0.20230088, 0.24247194,  # norm 1.3
+         0.38559628, 0.08184063, 0.1755943, -0.1582222]  # orthogonal
+    )
+    xp_assert_close(xp_vector_norm(unnormalized_dual_quat[:4]), xp.asarray(1.3)[()],
+                    atol=atol)
+    xp_assert_close(xp.vecdot(unnormalized_dual_quat[:4],
+                              unnormalized_dual_quat[4:])[()],
+                    xp.asarray(0.0)[()], atol=1e-8)
+
+    dq = xp.tile(unnormalized_dual_quat, shape + (1,))
+    dual_quat = RigidTransform.from_dual_quat(dq).as_dual_quat()
+
+    expected_ones = xp.ones(shape) if shape != () else xp.asarray(1.0)[()]
+    expected_zeros = xp.zeros(shape) if shape != () else xp.asarray(0.0)[()]
+    xp_assert_close(xp_vector_norm(dual_quat[..., :4], axis=-1), expected_ones,
+                    atol=1e-12)
+    vecdot = xp.vecdot(dual_quat[..., :4], dual_quat[..., 4:])
+    vecdot = vecdot[()] if vecdot.shape == () else vecdot
+    xp_assert_close(vecdot, expected_zeros, atol=atol)
+
+    # real and dual quaternion are not orthogonal
+    unnormalized_dual_quat = xp.asarray(
+        [0.20824458, 0.75098079, 0.54542913, -0.30849493,  # unit norm
+         -0.16051025, 0.10742978, 0.21277201, 0.20596935]  # not orthogonal
+    )
+    xp_assert_close(xp_vector_norm(unnormalized_dual_quat[:4]), xp.asarray(1.0)[()],
+                    atol=atol)
+    assert xp.vecdot(unnormalized_dual_quat[:4], unnormalized_dual_quat[4:]) != 0.0
+    dq = xp.tile(unnormalized_dual_quat, shape + (1,))
+    dual_quat = RigidTransform.from_dual_quat(dq).as_dual_quat()
+
+    xp_assert_close(xp_vector_norm(dual_quat[..., :4], axis=-1), expected_ones,
+                    atol=1e-12)
+    vecdot = xp.vecdot(dual_quat[..., :4], dual_quat[..., 4:])
+    vecdot = vecdot[()] if vecdot.shape == () else vecdot
+    xp_assert_close(vecdot, expected_zeros, atol=atol)
+
+    # invalid real quaternion with norm 0, non-orthogonal dual quaternion
+    unnormalized_dual_quat = xp.asarray(
+        [0.0, 0.0, 0.0, 0.0, -0.16051025, 0.10742978, 0.21277201, 0.20596935])
+    assert xp.vecdot(xp.asarray([0.0, 0, 0, 1]), unnormalized_dual_quat[4:]) != 0.0
+    dq = xp.tile(unnormalized_dual_quat, shape + (1,))
+    dual_quat = RigidTransform.from_dual_quat(dq).as_dual_quat()
+
+    xp_assert_close(xp_vector_norm(dual_quat[..., :4], axis=-1), expected_ones,
+                    atol=1e-12)
+    vecdot = xp.vecdot(dual_quat[..., :4], dual_quat[..., 4:])
+    vecdot = vecdot[()] if vecdot.shape == () else vecdot
+    xp_assert_close(vecdot, expected_zeros, atol=atol)
+
+    # compensation for precision loss in real quaternion
+    rng = np.random.default_rng(1000)
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    q = xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype)
+    r = Rotation.from_quat(q)
+    random_dual_quats = RigidTransform.from_components(t, r).as_dual_quat()
+
+    # ensure that random quaternions are not normalized
+    random_dual_quats = xpx.at(random_dual_quats)[..., :4].add(0.01)
+    assert not xp.any(xpx.isclose(xp_vector_norm(random_dual_quats[..., :4], axis=-1),
+                                  1.0, atol=0.0001))
+    dual_quat_norm = RigidTransform.from_dual_quat(
+        random_dual_quats).as_dual_quat()
+    xp_assert_close(xp_vector_norm(dual_quat_norm[..., :4], axis=-1), expected_ones,
+                    atol=atol)
+
+    # compensation for precision loss in dual quaternion, results in violation
+    # of orthogonality constraint
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    q = xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype)
+    r = Rotation.from_quat(q)
+    random_dual_quats = RigidTransform.from_components(t, r).as_dual_quat()
+
+    # ensure that random quaternions are not normalized
+    random_dual_quats = xpx.at(random_dual_quats)[..., 4:].add(0.1)
+    q_norm = xp.vecdot(random_dual_quats[..., :4], random_dual_quats[..., 4:])
+    assert not xp.any(xpx.isclose(q_norm, 0.0, atol=0.0001))
+    dual_quat_norm = RigidTransform.from_dual_quat(
+        random_dual_quats).as_dual_quat()
+    vecdot = xp.vecdot(dual_quat[..., :4], dual_quat[..., 4:])
+    vecdot = vecdot[()] if vecdot.shape == () else vecdot
+    xp_assert_close(vecdot, expected_zeros, atol=atol)
+    xp_assert_close(random_dual_quats[..., :4], dual_quat_norm[..., :4], atol=atol)
+
+
+def test_from_dual_quat_array_like():
+    rng = np.random.default_rng(123)
+    # Test single transform
+    t = np.array([1, 2, 3])
+    r = Rotation.random(rng=rng)
+    tf_expected = RigidTransform.from_components(t, r)
+    dual_quat = tf_expected.as_dual_quat().tolist()
+    assert isinstance(dual_quat, list)
+    tf = RigidTransform.from_dual_quat(dual_quat)
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix(), atol=1e-12)
+
+    # Test multiple transforms
+    t = [[1, 2, 3], [4, 5, 6]]
+    r = Rotation.random(len(t), rng=rng)
+    tf_expected = RigidTransform.from_components(t, r)
+    dual_quat = tf_expected.as_dual_quat().tolist()
+    assert isinstance(dual_quat, list)
+    tf = RigidTransform.from_dual_quat(dual_quat)
+    xp_assert_close(tf.as_matrix(), tf_expected.as_matrix(), atol=1e-12)
+
+
+@make_xp_test_case((RigidTransform, "as_dual_quat"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_as_dual_quat(xp, ndim: int):
+    dtype = xpx.default_dtype(xp)
+    shape = (ndim,) * (ndim - 1)
+    # identity
+    expected = xp.asarray([0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], dtype=dtype)
+    actual = rigid_transform_to_xp(RigidTransform.identity(), xp).as_dual_quat()
+    xp_assert_close(actual, expected, atol=1e-12)
+
+    expected = xp.asarray([1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+    tf = rigid_transform_to_xp(RigidTransform.identity(), xp)
+    actual = tf.as_dual_quat(scalar_first=True)
+    xp_assert_close(actual, expected, atol=1e-12)
+
+    rng = np.random.default_rng(10)
+
+    # only rotation
+    for _ in range(10):
+        q = xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype)
+        real_part = Rotation.from_quat(q).as_quat()
+        dual_part = xp.zeros_like(real_part)
+        expected = xp.concat((real_part, dual_part), axis=-1)
+        actual = RigidTransform.from_dual_quat(expected).as_dual_quat()
+        # because of double cover:
+        actual = actual * xp.sign(actual[..., 0, None])
+        expected = expected * xp.sign(expected[..., 0, None])
+        xp_assert_close(actual, expected, atol=1e-12)
+
+    # only translation
+    for _ in range(10):
+        tf = 0.5 * xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+        expected = xp.zeros(shape + (8,), dtype=dtype)
+        expected = xpx.at(expected)[..., 3].set(1.0)
+        expected = xpx.at(expected)[..., 4:7].set(tf)
+        actual = RigidTransform.from_dual_quat(expected).as_dual_quat()
+        # because of double cover:
+        actual = actual * xp.sign(actual[..., 0, None])
+        expected = expected * xp.sign(expected[..., 0, None])
+        xp_assert_close(actual, expected, atol=1e-12)
+
+    # rotation and translation
+    for _ in range(10):
+        t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+        r = Rotation.from_quat(xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype))
+        expected = RigidTransform.from_components(t, r).as_dual_quat()
+        actual = RigidTransform.from_dual_quat(expected).as_dual_quat()
+        # because of double cover:
+        actual = actual * xp.sign(actual[..., 0, None])
+        expected = expected * xp.sign(expected[..., 0, None])
+        xp_assert_close(actual, expected, atol=1e-12)
+
+
+@make_xp_test_case(
+    (RigidTransform, "from_components"), (RigidTransform, "as_components"),
+    (RigidTransform, "from_exp_coords"), (RigidTransform, "as_exp_coords"),
+    (RigidTransform, "from_matrix"), (RigidTransform, "as_matrix"),
+    (RigidTransform, "from_dual_quat"), (RigidTransform, "as_dual_quat")
+)
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_from_as_internal_consistency(xp, ndim: int):
+    dtype = xpx.default_dtype(xp)
+    atol = 1e-12
+    n = 10
+    rng = np.random.default_rng(10)
+    shape = (n,) + (ndim,) * (ndim - 1)
+
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    r = Rotation.from_quat(xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype))
+    tf0 = RigidTransform.from_components(t, r)
+
+    tf1 = RigidTransform.from_components(*tf0.as_components())
+    xp_assert_close(tf0.as_matrix(), tf1.as_matrix(), atol=atol)
+
+    tf1 = RigidTransform.from_components(tf0.translation, tf0.rotation)
+    xp_assert_close(tf0.as_matrix(), tf1.as_matrix(), atol=atol)
+
+    tf1 = RigidTransform.from_exp_coords(tf0.as_exp_coords())
+    xp_assert_close(tf0.as_matrix(), tf1.as_matrix(), atol=atol)
+
+    tf1 = RigidTransform.from_matrix(tf0.as_matrix())
+    xp_assert_close(tf0.as_matrix(), tf1.as_matrix(), atol=atol)
+
+    tf1 = RigidTransform.from_dual_quat(tf0.as_dual_quat())
+    xp_assert_close(tf0.as_matrix(), tf1.as_matrix(), atol=atol)
+
+    # exp_coords small rotation
+    t = xp.asarray(rng.normal(scale=1000.0, size=shape + (3,)), dtype=dtype)
+    rotvec = xp.asarray(rng.normal(scale=1e-10, size=shape + (3,)), dtype=dtype)
+    r = Rotation.from_rotvec(rotvec)
+    tf0 = RigidTransform.from_components(t, r)
+    tf1 = RigidTransform.from_exp_coords(tf0.as_exp_coords())
+    xp_assert_close(tf0.as_matrix(), tf1.as_matrix(), atol=atol)
+
+
+def test_identity():
+    # We do not use xp here because identity always returns numpy arrays
+    atol = 1e-12
+    # Test single identity
+    tf = RigidTransform.identity()
+    xp_assert_close(tf.as_matrix(), np.eye(4), atol=atol)
+    # Test multiple identities
+    tf = RigidTransform.identity(5)
+    xp_assert_close(tf.as_matrix(), np.array([np.eye(4)] * 5), atol=atol)
+    # Test shape
+    tf = RigidTransform.identity(shape=3)
+    expected = np.tile(np.eye(4), (3, 1, 1))
+    xp_assert_close(tf.as_matrix(), expected, atol=atol)
+    tf = RigidTransform.identity(shape=(2, 3))
+    expected = np.tile(np.eye(4), (2, 3, 1, 1))
+    xp_assert_close(tf.as_matrix(), expected, atol=atol)
+    # Test errors
+    with pytest.raises(ValueError, match="Only one of `num` and `shape` can be."):
+        RigidTransform.identity(10, shape=(2, 3))
+    with pytest.raises(TypeError, match="takes from 0 to 1 positional arguments"):
+        RigidTransform.identity(None, (-1, 3))  # Shape is kwarg only
+    with pytest.raises(ValueError, match="`shape` must be an int or a tuple of ints"):
+        RigidTransform.identity(shape="invalid")
+
+
+@make_xp_test_case((RigidTransform, "apply"))
+def test_apply(xp):
+    atol = 1e-12
+    # Broadcast shape: (6, 5, 4, 2) ( + (3,) for vectors, + (4,) for rotations)
+    vector_shapes = [(), (1,), (2,), (1, 2), (5, 1, 2)]
+    tf_shapes = [(), (1,), (2,), (1, 2), (4, 2), (1, 4, 2), (5, 4, 2), (6, 5, 4, 2)]
+    rng = np.random.default_rng(123)
+
+    for tf_shape, v_shape in product(tf_shapes, vector_shapes):
+        # Random rotation and translation
+        t = xp.asarray(rng.normal(size=tf_shape + (3,)))
+        q = xp.asarray(rng.normal(size=tf_shape + (4,)))
+        r = Rotation.from_quat(q)
+        tf = RigidTransform.from_components(t, r)
+
+        vecs = xp.asarray(rng.normal(size=v_shape + (3,)))
+        expected = t + r.apply(vecs)
+        res = tf.apply(vecs)
+        assert res.shape == np.broadcast_shapes(tf_shape, v_shape) + (3,)
+        xp_assert_close(res, expected, atol=atol)
+
+
+def test_apply_array_like():
+    rng = np.random.default_rng(123)
+    # Single vector
+    t = np.array([1, 2, 3])
+    r = Rotation.random(rng=rng)
+    tf = RigidTransform.from_components(t, r)
+    vec = [1, 0, 0]
+    expected = t + r.apply(vec)
+    xp_assert_close(tf.apply(vec), expected, atol=1e-12)
+
+    # Multiple vectors
+    t = np.array([[1, 2, 3], [4, 5, 6]])
+    r = Rotation.random(len(t), rng=rng)
+    tf = RigidTransform.from_components(t, r)
+    vec = [[1, 0, 0], [0, 1, 0]]
+    expected = t + r.apply(vec)
+    xp_assert_close(tf.apply(vec), expected, atol=1e-12)
+
+
+def test_apply_matrix_equivalence():
+    """Test documented equivalence for single transform:
+    `apply(vector) == translation + vector @ rotation.as_matrix().T.`"""
+    t = np.array([1.0, 2.0, 3.0])
+    r = Rotation.from_rotvec([0, 0, 1])
+    tf = RigidTransform.from_components(t, r)
+    # Single vector (3,)
+    v = np.array([1.0, 0.0, 0.0])
+    xp_assert_close(tf.apply(v), t + v @ r.as_matrix().T)
+    # Multiple vectors (P, 3)
+    arr = np.array([[1, 0, 0], [0, 1, 0]], dtype=float)
+    xp_assert_close(tf.apply(arr), t + arr @ r.as_matrix().T)
+
+
+@make_xp_test_case((RigidTransform, "apply"))
+def test_inverse_apply(xp):
+    atol = 1e-12
+    # Broadcast shape: (6, 5, 4, 2) ( + (3,) for vectors, + (4,) for rotations)
+    vector_shapes = [(), (1,), (2,), (1, 2), (5, 1, 2)]
+    tf_shapes = [(), (1,), (2,), (1, 2), (4, 2), (1, 4, 2), (5, 4, 2), (6, 5, 4, 2)]
+    rng = np.random.default_rng(123)
+
+    for tf_shape, v_shape in product(tf_shapes, vector_shapes):
+        # Random rotation and translation
+        t = xp.asarray(rng.normal(size=tf_shape + (3,)))
+        q = xp.asarray(rng.normal(size=tf_shape + (4,)))
+        r = Rotation.from_quat(q)
+        tf = RigidTransform.from_components(t, r)
+
+        vecs = xp.asarray(rng.normal(size=v_shape + (3,)))
+        expected = tf.inv().apply(vecs)
+        res = tf.apply(vecs, inverse=True)
+        assert res.shape == np.broadcast_shapes(tf_shape, v_shape) + (3,)
+        xp_assert_close(res, expected, atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "apply"))
+def test_rotation_alone(xp):
+    atol = 1e-12
+
+    r = Rotation.from_euler('z', xp.asarray(90), degrees=True)
+    tf = RigidTransform.from_rotation(r)
+    vec = xp.asarray([1, 0, 0])
+    expected = r.apply(vec)
+    xp_assert_close(tf.apply(vec), expected, atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "apply"))
+def test_translation_alone(xp):
+    atol = 1e-12
+    t = xp.asarray([1.0, 2, 3])
+    tf = RigidTransform.from_translation(t)
+    vec = xp.asarray([5.0, 6, 7])
+    expected = t + vec
+    xp_assert_close(tf.apply(vec), expected, atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "apply"), (RigidTransform, "__mul__"))
+def test_composition(xp):
+    atol = 1e-12
+    tf_shapes = [(), (1,), (2,), (1, 2), (4, 2), (5, 4, 2)]
+    dtype = xpx.default_dtype(xp)
+    rng = np.random.default_rng(123)
+
+    for tf_shape1, tf_shape2 in product(tf_shapes, repeat=2):
+        # Random rotation and translation
+        t1 = xp.asarray(rng.normal(size=tf_shape1 + (3,)))
+        q1 = xp.asarray(rng.normal(size=tf_shape1 + (4,)))
+        r1 = Rotation.from_quat(q1)
+        tf1 = RigidTransform.from_components(t1, r1)
+
+        t2 = xp.asarray(rng.normal(size=tf_shape2 + (3,)))
+        q2 = xp.asarray(rng.normal(size=tf_shape2 + (4,)))
+        r2 = Rotation.from_quat(q2)
+        tf2 = RigidTransform.from_components(t2, r2)
+
+        composed = tf2 * tf1
+        vec = xp.asarray(rng.normal(size=(3,)), dtype=dtype)
+        expected = tf2.apply(tf1.apply(vec))
+        res = composed.apply(vec)
+        assert res.shape == np.broadcast_shapes(tf_shape1, tf_shape2) + (3,)
+        xp_assert_close(res, expected, atol=atol)
+
+        expected = t2 + r2.apply(t1 + r1.apply(vec))
+        xp_assert_close(composed.apply(vec), expected, atol=atol)
+        assert composed.single == (tf1.single and tf2.single)
+
+
+@make_xp_test_case((RigidTransform, "__pow__"), (RigidTransform, "__mul__"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_pow(xp, ndim: int):
+    dtype = xpx.default_dtype(xp)
+    atol = 1e-12 if dtype == xp.float64 else 1e-6
+    num = 10
+    rng = np.random.default_rng(100)
+    shape = (num,) + (ndim,) * (ndim - 1)
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    q = xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype)
+    r = Rotation.from_quat(q)
+    p = RigidTransform.from_components(t, r)
+    p_inv = p.inv()
+
+    # Test the short-cuts and other integers
+    for n in [-5, -2, -1, 0, 1, 2, 5]:
+        q = p**n
+        # Regression test for gh-24436
+        assert isinstance(q._matrix, type(p._matrix))
+        r = RigidTransform.from_matrix(xp.tile(xp.eye(4), shape + (1, 1)))
+        for _ in range(abs(n)):
+            if n > 0:
+                r = r * p
+            else:
+                r = r * p_inv
+        xp_assert_close(q.as_matrix(), r.as_matrix(), atol=atol)
+
+    # Test shape preservation of single
+    single_tf = RigidTransform.identity()
+    assert (single_tf**n).as_matrix().shape == (4, 4)
+
+    # Test fractional powers
+    q = p**0.5
+    xp_assert_close((q * q).as_matrix(), p.as_matrix(), atol=atol)
+    q = p**-0.5
+    xp_assert_close((q * q).as_matrix(), p.inv().as_matrix(), atol=atol)
+    q = p** 1.5
+    xp_assert_close((q * q).as_matrix(), (p**3).as_matrix(), atol=atol)
+    q = p** -1.5
+    xp_assert_close((q * q).as_matrix(), (p**-3).as_matrix(), atol=atol)
+
+    # pow function
+    tf = pow(RigidTransform.from_matrix(xp.eye(4)), 2)
+    xp_assert_close(tf.as_matrix(), xp.eye(4), atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "__pow__"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_pow_equivalence_with_rotation(xp, ndim: int):
+    atol = 1e-12
+    num = 10
+    rng = np.random.default_rng(100)
+    dtype = xpx.default_dtype(xp)
+    shape = (num,) + (ndim,) * (ndim - 1)
+
+    r = Rotation.from_quat(xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype))
+    p = RigidTransform.from_rotation(r)
+    for n in [-5, -2, -1.5, -1, -0.5, 0.0, 0.5, 1, 1.5, 2, 5]:
+        xp_assert_close((p**n).rotation.as_matrix(), (r**n).as_matrix(), atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "inv"), (RigidTransform, "__mul__"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_inverse(xp, ndim: int):
+    dtype = xpx.default_dtype(xp)
+    atol = 1e-12 if dtype == xp.float64 else 1e-6
+    rng = np.random.default_rng(100)
+    shape = (ndim,) * (ndim - 1)
+
+    # Test inverse transform
+    r = Rotation.from_quat(xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype))
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    tf = RigidTransform.from_components(t, r)
+
+    # Test that tf * tf.inv() equals identity
+    tf_inv = tf.inv()
+    composed = tf * tf_inv
+    expected = xp.tile(xp.eye(4), shape + (1, 1))
+    xp_assert_close(composed.as_matrix(), expected, atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "as_matrix"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_properties(xp, ndim: int):
+    atol = 1e-12 if xpx.default_dtype(xp) == xp.float64 else 1e-6
+    shape = (ndim,) * (ndim - 1)
+    dtype = xpx.default_dtype(xp)
+    rng = np.random.default_rng(100)
+
+    # Test rotation and translation properties
+    r = Rotation.from_quat(xp.asarray(rng.normal(size=shape + (4,)), dtype=dtype))
+    t = xp.asarray(rng.normal(size=shape + (3,)), dtype=dtype)
+    tf = RigidTransform.from_components(t, r)
+
+    xp_assert_close(tf.rotation.as_matrix(), r.as_matrix(), atol=atol)
+    assert xp.all(tf.rotation.approx_equal(r, atol=atol))
+    xp_assert_close(tf.translation, t, atol=atol)
+    # Test that we don't return views that would modify the original array
+    xpx.at(tf.translation)[..., 0].set(0.0)
+    xp_assert_close(tf.translation, t, atol=atol)
+    assert tf.single == (shape == ())
+
+
+@make_xp_test_case((RigidTransform, "__getitem__"))
+def test_indexing(xp):
+    atol = 1e-12
+
+    # Test indexing for multiple transforms
+    r = Rotation.from_euler('zyx', xp.asarray([[90, 0, 0], [0, 90, 0]]), degrees=True)
+    t = xp.asarray([[1.0, 2, 3], [4, 5, 6]])
+    tf = RigidTransform.from_components(t, r)
+
+    # Test single index
+    xp_assert_close(tf[0].as_matrix()[:3, :3], r[0].as_matrix(), atol=atol)
+    xp_assert_close(tf[0].as_matrix()[:3, 3], t[0, ...], atol=atol)
+
+    # Test slice
+    tf_slice = tf[0:2]
+    xp_assert_close(tf_slice.as_matrix()[:, :3, :3], r[0:2].as_matrix(), atol=atol)
+    xp_assert_close(tf_slice.as_matrix()[:, :3, 3], t[0:2, ...], atol=atol)
+
+    # Test boolean indexing
+    tf_masked = tf[xp.asarray([True, True])]
+    xp_assert_close(tf_masked.as_matrix()[:, :3, :3], r.as_matrix(), atol=atol)
+    xp_assert_close(tf_masked.as_matrix()[:, :3, 3], t, atol=atol)
+
+    tf_masked = tf[xp.asarray([False, True])]
+    xp_assert_close(tf_masked.as_matrix()[:, :3, :3],
+                    r[xp.asarray([False, True])].as_matrix(), atol=atol)
+    xp_assert_close(tf_masked.as_matrix()[:, :3, 3], t[xp.asarray([False, True])],
+                    atol=atol)
+
+    tf_masked = tf[xp.asarray([False, False])]
+    assert len(tf_masked) == 0
+
+    # Test integer array indexing
+    idx = xp.asarray([0, 1])
+    xp_assert_close(tf[idx].as_matrix()[:, :3, :3], r[idx].as_matrix(), atol=atol)
+    xp_assert_close(tf[idx].as_matrix()[:, :3, 3], t, atol=atol)
+
+
+def test_indexing_array_like():
+    atol = 1e-12
+
+    r = Rotation.from_euler('zyx', np.array([[90, 0, 0], [0, 90, 0]]), degrees=True)
+    t = np.array([[1.0, 2, 3], [4, 5, 6]])
+    tf = RigidTransform.from_components(t, r)
+
+    tf_masked = tf[[False, True]]
+    xp_assert_close(tf_masked.as_matrix()[:, :3, :3], r[[False, True]].as_matrix(),
+                    atol=atol)
+    xp_assert_close(tf_masked.as_matrix()[:, :3, 3], t[[False, True]], atol=atol)
+    tf_masked = tf[[False, False]]
+    assert len(tf_masked) == 0
+
+
+@make_xp_test_case((RigidTransform, "concatenate"))
+def test_concatenate(xp):
+    atol = 1e-12
+
+    # Test concatenation of transforms
+    t1 = xp.asarray([1, 0, 0])
+    r1 = Rotation.from_euler('z', xp.asarray(90), degrees=True)
+    tf1 = RigidTransform.from_components(t1, r1)
+
+    t2 = xp.asarray([0, 1, 0])
+    r2 = Rotation.from_euler('x', xp.asarray(90), degrees=True)
+    tf2 = RigidTransform.from_components(t2, r2)
+
+    # Concatenate single transforms
+    concatenated1 = RigidTransform.concatenate([tf1, tf2])
+    xp_assert_close(concatenated1[0].as_matrix(), tf1.as_matrix(), atol=atol)
+    xp_assert_close(concatenated1[1].as_matrix(), tf2.as_matrix(), atol=atol)
+
+    # Concatenate multiple transforms
+    concatenated2 = RigidTransform.concatenate([tf1, concatenated1])
+    xp_assert_close(concatenated2[0].as_matrix(), tf1.as_matrix(), atol=atol)
+    xp_assert_close(concatenated2[1].as_matrix(), tf1.as_matrix(), atol=atol)
+    xp_assert_close(concatenated2[2].as_matrix(), tf2.as_matrix(), atol=atol)
+
+    # Test ND concatenation
+    tf3 = RigidTransform.from_translation(xp.reshape(xp.arange(18), (3, 2, 3)))
+    tf4 = RigidTransform.from_translation(xp.reshape(xp.arange(18) + 18, (3, 2, 3)))
+    concatenated3 = RigidTransform.concatenate([tf3, tf4])
+    xp_assert_close(concatenated3.as_matrix()[:3, ...], tf3.as_matrix(), atol=atol)
+    xp_assert_close(concatenated3.as_matrix()[3:, ...], tf4.as_matrix(), atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"))
+def test_input_validation(xp):
+    # Test invalid matrix shapes
+    inputs = [xp.eye(3), xp.zeros((4, 3)), []]
+    for input in inputs:
+        with pytest.raises(ValueError, match="Expected `matrix` to have shape"):
+            RigidTransform.from_matrix(input)
+
+    # Test invalid last row
+    for ndim in range(3):
+        shape = (ndim,) * (ndim - 1)
+        matrix = xp.zeros(shape + (4, 4))
+        matrix = xpx.at(matrix)[...].set(xp.eye(4))
+        matrix = xpx.at(matrix)[..., 3, :].set(xp.asarray([1.0, 0, 0, 1]))
+        if is_lazy_array(matrix):
+            matrix = RigidTransform.from_matrix(matrix).as_matrix()
+            assert xp.all(xp.isnan(matrix[..., 3, :]))
+        else:
+            with pytest.raises(ValueError, match="last row of transformation matrix"):
+                RigidTransform.from_matrix(matrix)
+
+    # Test left handed rotation matrix
+    matrix = xp.eye(4)
+    matrix = xpx.at(matrix)[0, 0].set(-1)
+    if is_lazy_array(matrix):
+        matrix = RigidTransform.from_matrix(matrix).as_matrix()
+        assert xp.all(xp.isnan(matrix[..., :3, :3]))
+    else:
+        with pytest.raises(ValueError, match="Non-positive determinant"):
+            RigidTransform(matrix, normalize=True)
+
+    # Test non-Rotation input
+    with pytest.raises(TypeError,
+                       match="Expected `rotation` to be a `Rotation` instance"):
+        RigidTransform.from_rotation(xp.eye(3))
+
+
+@make_xp_test_case((RigidTransform, "mean"))
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_mean(xp, ndim: int):
+    atol = 1e-12
+    rng = np.random.default_rng(123)
+
+    dtype = xpx.default_dtype(xp)
+    t = xp.asarray(rng.normal(size=(ndim,) * (ndim - 1) + (3,)), dtype=dtype)
+    q = xp.asarray(rng.normal(size=(ndim,) * (ndim - 1) + (4,)), dtype=dtype)
+    r = Rotation.from_quat(q)
+    tf = RigidTransform.from_components(t, r)
+
+    # Unweighted mean
+    axis = tuple(range(t.ndim - 1))
+    t_mean = xp.mean(t, axis=axis)
+    r_mean = r.mean()
+    tf_mean = tf.mean()
+    assert tf_mean.shape == ()
+    xp_assert_close(tf_mean.as_matrix(),
+                    RigidTransform.from_components(t_mean, r_mean).as_matrix(),
+                    atol=atol)
+
+    # Weighted mean
+    if ndim == 1:
+        weights = None
+        t_mean = t
+    else:
+        weights = xp.asarray(rng.random(size=(ndim,) * (ndim - 1)), dtype=dtype)
+        norm = xp.sum(weights[..., None], axis=axis)
+        wsum = xp.sum(t * weights[..., None], axis=axis)
+        t_mean = wsum/norm
+    r_mean = r.mean(weights=weights)
+    tf_mean = tf.mean(weights=weights)
+    assert tf_mean.shape == ()
+    xp_assert_close(tf_mean.as_matrix(),
+                    RigidTransform.from_components(t_mean, r_mean).as_matrix(),
+                    atol=atol)
+
+
+@make_xp_test_case(
+    (RigidTransform, "from_rotation"), (RigidTransform, "mean"), (Rotation, "magnitude")
+)
+@pytest.mark.parametrize("ndim", range(1, 5))
+def test_mean_axis(xp, ndim: int):
+    axes = xp.tile(xp.concat((-xp.eye(3), xp.eye(3))), (3,) * (ndim - 1) + (1, 1))
+    theta = xp.pi / 4
+    r = Rotation.from_rotvec(theta * axes)
+    tf = RigidTransform.from_rotation(r)
+
+    # Test mean over last axis
+    desired = xp.full(axes.shape[:-2], 0.0)
+    if ndim == 1:
+        desired = desired[()]
+    atol = 1e-6 if xpx.default_dtype(xp) is xp.float32 else 1e-10
+    xp_assert_close(tf.mean(axis=-1).rotation.magnitude(), desired, atol=atol)
+
+    # Test tuple axes
+    desired = xp.full(axes.shape[1:-2], 0.0)
+    if ndim < 3:
+        desired = desired[()]
+    xp_assert_close(tf.mean(axis=(0, -1)).rotation.magnitude(), desired, atol=atol)
+
+    # Empty axis tuple should return RigidTransform unchanged
+    tf_mean = tf.mean(axis=())
+    xp_assert_close(tf_mean.as_matrix(), tf.as_matrix(), atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "mean"), (Rotation, "magnitude"))
+def test_mean_compare_axis(xp):
+    # Create a random set of transforms and compare the mean over an axis with
+    # the mean without axis of the sliced transform
+    atol = 1e-10 if xpx.default_dtype(xp) == xp.float64 else 1e-6
+    rng = np.random.default_rng(0)
+    q = xp.asarray(rng.normal(size=(4, 5, 6, 4)), dtype=xpx.default_dtype(xp))
+    r = Rotation.from_quat(q)
+    t = xp.asarray(rng.normal(size=(4, 5, 6, 3)), dtype=xpx.default_dtype(xp))
+    tf = RigidTransform.from_components(t, r)
+
+    mean_0 = tf.mean(axis=0)
+    for i in range(q.shape[1]):
+        for j in range(q.shape[2]):
+            r_slice = Rotation.from_quat(q[:, i, j, ...])
+            t_slice = t[:, i, j, ...]
+            mean_slice_tf = RigidTransform.from_components(t_slice, r_slice).mean()
+            xp_assert_close(
+                (mean_0[i][j].rotation * mean_slice_tf.rotation.inv()).magnitude(),
+                xp.asarray(0.0)[()], atol=atol,
+            )
+            xp_assert_close(
+                mean_0[i][j].translation, mean_slice_tf.translation, atol=atol,
+            )
+    mean_1_2 = tf.mean(axis=(1, 2))
+    for i in range(q.shape[0]):
+        r_slice = Rotation.from_quat(q[i, ...])
+        t_slice = t[i, ...]
+        mean_slice_tf = RigidTransform.from_components(t_slice, r_slice).mean()
+        xp_assert_close(
+            (mean_1_2[i].rotation * mean_slice_tf.rotation.inv()).magnitude(),
+            xp.asarray(0.0)[()], atol=atol,
+        )
+        xp_assert_close(
+            mean_1_2[i].translation, mean_slice_tf.translation, atol=atol,
+        )
+
+
+@make_xp_test_case((RigidTransform, "mean"))
+def test_mean_invalid_weights(xp):
+    tf = RigidTransform.from_matrix(xp.tile(xp.eye(4), (4, 1, 1)))
+    if is_lazy_array(tf.as_matrix()):
+        m = tf.mean(weights=-xp.ones(4))
+        assert xp.all(xp.isnan(m.as_matrix()))
+    else:
+        with pytest.raises(ValueError, match="non-negative"):
+            tf.mean(weights=-xp.ones(4))
+
+    # Test weight shape mismatch
+    tf = RigidTransform.from_matrix(xp.eye(4))
+    with pytest.raises(ValueError, match="Expected `weights` to"):
+        tf.mean(weights=xp.ones((2,)))
+    tf = RigidTransform.from_matrix(xp.tile(xp.eye(4), (3, 2, 1, 1, 1)))
+    with pytest.raises(ValueError, match="Expected `weights` to"):
+        tf.mean(weights=xp.ones((2, 1)))
+
+
+@make_xp_test_case((RigidTransform, "from_translation"))
+def test_translation_validation(xp):
+    # Test invalid translation shapes
+    with pytest.raises(ValueError, match="Expected `translation` to have shape"):
+        RigidTransform.from_translation(xp.asarray([1, 2]))
+
+    with pytest.raises(ValueError, match="Expected `translation` to have shape"):
+        RigidTransform.from_translation(xp.zeros((2, 2)))
+
+
+@make_xp_test_case((RigidTransform, "apply"))
+def test_vector_validation(xp):
+    tf = rigid_transform_to_xp(RigidTransform.identity(2), xp=xp)
+
+    # Test invalid vector shapes
+    with pytest.raises(ValueError, match="Expected vector to have shape"):
+        tf.apply(xp.asarray([1, 2]))
+
+    with pytest.raises(ValueError, match="Expected vector to have shape"):
+        tf.apply(xp.zeros((2, 2)))
+
+    with pytest.raises(ValueError, match="operands could not be broadcast"):
+        tf.apply(xp.zeros((1, 4, 3)))
+
+
+@make_xp_test_case((RigidTransform, "__getitem__"))
+def test_indexing_validation(xp):
+    tf = RigidTransform.from_matrix(xp.eye(4))
+
+    # Test indexing on single transform
+    with pytest.raises(TypeError, match="Single transform is not subscriptable"):
+        tf[0]
+
+    with pytest.raises(TypeError, match="Single transform is not subscriptable"):
+        tf[0:1]
+
+    # Test length on single transform
+    with pytest.raises(TypeError, match="Single transform has no len"):
+        len(tf)
+
+
+@make_xp_test_case((RigidTransform, "__mul__"))
+def test_composition_validation(xp):
+    tf2 = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6]]))
+    tf3 = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+
+    # Test incompatible shapes
+    with pytest.raises(ValueError, match="Cannot broadcast"):
+        tf2 * tf3
+
+    tf4 = RigidTransform.from_matrix(xp.tile(xp.eye(4), (1, 4, 1, 1)))
+    # Test invalid broadcasting shape
+    with pytest.raises(ValueError, match="Cannot broadcast"):
+        tf2 * tf4
+
+
+@make_xp_test_case((RigidTransform, "__mul__"), (RigidTransform, "__rmul__"))
+def test_rotation_promotion(xp):
+    """Test that Rotation is promoted to RigidTransform in composition."""
+    atol = 1e-12
+    dtype = xpx.default_dtype(xp)
+    rng = np.random.default_rng(0)
+
+    t = xp.asarray(rng.normal(size=(3,)), dtype=dtype)
+    r1 = rotation_to_xp(Rotation.random(rng=rng), xp)
+    r2 = rotation_to_xp(Rotation.random(rng=rng), xp)
+    tf = RigidTransform.from_components(t, r2)
+
+    # RigidTransform * Rotation
+    result = tf * r1
+    expected = tf * RigidTransform.from_rotation(r1)
+    assert isinstance(result, RigidTransform)
+    xp_assert_close(result.as_matrix(), expected.as_matrix(), atol=atol)
+
+    # Rotation * RigidTransform
+    result = r1 * tf
+    expected = RigidTransform.from_rotation(r1) * tf
+    assert isinstance(result, RigidTransform)
+    xp_assert_close(result.as_matrix(), expected.as_matrix(), atol=atol)
+
+
+@make_xp_test_case((RigidTransform, "concatenate"))
+def test_concatenate_validation(xp):
+    tf = RigidTransform.from_matrix(xp.eye(4))
+
+    # Test invalid inputs
+    with pytest.raises(TypeError,
+                       match="input must contain RigidTransform objects"):
+        RigidTransform.concatenate([tf, xp.eye(4)])
+
+    # Test incompatible shapes
+    tf2 = RigidTransform.from_translation(xp.ones((1, 1, 1, 3)))
+    # Frameworks have a highly heterogeneous way of reporting errors for this case
+    with pytest.raises((ValueError, TypeError, RuntimeError)):
+        RigidTransform.concatenate([tf, tf2])
+
+
+@make_xp_test_case((RigidTransform, "__setitem__"))
+def test_setitem(xp):
+    tf = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+    single = RigidTransform.from_translation(xp.asarray([1, 1, 1]))
+    double = RigidTransform.from_translation(xp.asarray([[2, 2, 2], [3, 3, 3]]))
+    triple = RigidTransform.from_translation(xp.asarray([[3, 3, 3],
+                                                         [4, 4, 4],
+                                                         [5, 5, 5]]))
+
+    # Test indexing with integer index
+    tf[0] = single
+    xp_assert_close(tf.translation, xp.asarray([[1.0, 1, 1], [4, 5, 6], [7, 8, 9]]))
+
+    # Test indexing with slice
+    tf = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+    tf[:2] = double
+    xp_assert_close(tf.translation, xp.asarray([[2.0, 2, 2], [3, 3, 3], [7, 8, 9]]))
+
+    # Test indexing with ellipsis
+    tf = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+    tf[...] = triple
+    xp_assert_close(tf.translation, xp.asarray([[3.0, 3, 3], [4, 4, 4], [5, 5, 5]]))
+
+    # Test indexing with boolean array
+    tf = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+    mask = xp.asarray([True, False, True])
+    tf[mask] = double
+    xp_assert_close(tf.translation, xp.asarray([[2.0, 2, 2], [4, 5, 6], [3, 3, 3]]))
+
+
+@make_xp_test_case((RigidTransform, "__setitem__"))
+@pytest.mark.skip_xp_backends("array_api_strict",
+                              reason="doesn't support fancy indexing __setitem__")
+def test_setitem_fancy_indexing(xp):
+    double = RigidTransform.from_translation(xp.asarray([[2, 2, 2], [3, 3, 3]]))
+    tf = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
+    idx = xp.asarray([0, 2])
+    tf[idx] = double
+    xp_assert_close(tf.translation, xp.asarray([[2.0, 2, 2], [4, 5, 6], [3, 3, 3]]))
+
+
+@make_xp_test_case((RigidTransform, "__setitem__"))
+def test_setitem_validation(xp):
+    tf = RigidTransform.from_translation(xp.asarray([[1, 2, 3], [4, 5, 6]]))
+    single = RigidTransform.from_matrix(xp.eye(4))
+
+    # Test setting item on single transform
+    with pytest.raises(TypeError, match="Single transform is not subscriptable"):
+        single[0] = tf
+
+    # Test invalid value type
+    with pytest.raises(TypeError, match="value must be a RigidTransform"):
+        tf[0] = xp.eye(4)
+
+
+@pytest.mark.skip_xp_backends("jax.numpy",
+                              reason="JAX does not support memory sharing")
+@make_xp_test_case((RigidTransform, "as_matrix"))
+def test_copy_flag(xp):
+    # Test that copy=True creates new memory
+    matrix = xp.eye(4)
+    tf = RigidTransform(matrix, normalize=False, copy=True)
+    matrix[0, 0] = 2
+    assert tf.as_matrix()[0, 0] == 1
+
+    # Test that copy=False shares memory
+    matrix = xp.eye(4)
+    tf = RigidTransform(matrix, normalize=False, copy=False)
+    matrix[0, 0] = 2
+    assert tf.as_matrix()[0, 0] == 2
+
+
+@make_xp_test_case(normalize_dual_quaternion)
+@pytest.mark.parametrize("ndim", range(1, 4))
+def test_normalize_dual_quaternion(xp, ndim: int):
+    dtype = xpx.default_dtype(xp)
+    atol = 1e-12 if dtype == xp.float64 else 1e-6
+    rng = np.random.default_rng(100)
+    shape = (ndim,) * (ndim - 1)
+
+    dual_quat = normalize_dual_quaternion(xp.zeros((1, 8)))
+    xp_assert_close(xp_vector_norm(dual_quat[0, :4], axis=-1), xp.asarray(1.0)[()],
+                    atol=1e-12)
+    xp_assert_close(xp.vecdot(dual_quat[0, :4], dual_quat[0, 4:])[()],
+                    xp.asarray(0.0)[()], atol=1e-12)
+
+    dual_quat = xp.asarray(rng.normal(size=shape + (8,)), dtype=dtype)
+    dual_quat = normalize_dual_quaternion(dual_quat)
+    expected = xp.ones(shape) if shape != () else xp.asarray(1.0)[()]
+    xp_assert_close(xp_vector_norm(dual_quat[..., :4], axis=-1), expected, atol=atol)
+    expected = xp.zeros(shape) if shape != () else xp.asarray(0.0)[()]
+    vecdot = xp.vecdot(dual_quat[..., :4], dual_quat[..., 4:])
+    vecdot = vecdot[()] if vecdot.shape == () else vecdot
+    xp_assert_close(vecdot, expected, atol=atol)
+
+
+@make_xp_test_case(
+    (RigidTransform, "from_matrix"), (RigidTransform, "from_rotation"),
+    (RigidTransform, "from_translation"), (RigidTransform, "from_components"),
+    (RigidTransform, "from_exp_coords"), (RigidTransform, "from_dual_quat")
+)
+def test_empty_transform_construction(xp):
+    tf = RigidTransform.from_matrix(xp.empty((0, 4, 4)))
+    assert len(tf) == 0
+    assert not tf.single
+
+    tf = RigidTransform.from_rotation(Rotation.from_quat(xp.zeros((0, 4))))
+    assert len(tf) == 0
+    assert not tf.single
+
+    tf = RigidTransform.from_translation(xp.empty((0, 3)))
+    assert len(tf) == 0
+    assert not tf.single
+
+    empty_rot = Rotation.from_quat(xp.zeros((0, 4)))
+    tf = RigidTransform.from_components(xp.empty((0, 3)), empty_rot)
+    assert len(tf) == 0
+    assert not tf.single
+
+    tf = RigidTransform.from_exp_coords(xp.empty((0, 6)))
+    assert len(tf) == 0
+    assert not tf.single
+
+    tf = RigidTransform.from_dual_quat(xp.empty((0, 8)))
+    assert len(tf) == 0
+    assert not tf.single
+
+    tf = RigidTransform.identity(0)
+    assert len(tf) == 0
+    assert not tf.single
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"), (RigidTransform, "as_components"),
+                   (RigidTransform, "as_exp_coords"), (RigidTransform, "as_dual_quat"))
+def test_empty_transform_representation(xp):
+    tf = RigidTransform.from_matrix(xp.empty((0, 4, 4)))
+
+    assert len(tf.rotation) == 0
+    assert tf.translation.shape == (0, 3)
+
+    t, r = tf.as_components()
+    assert t.shape == (0, 3)
+    assert len(r) == 0
+
+    assert tf.as_matrix().shape == (0, 4, 4)
+    assert tf.as_exp_coords().shape == (0, 6)
+    assert tf.as_dual_quat().shape == (0, 8)
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"), (RigidTransform, "apply"))
+def test_empty_transform_application(xp):
+    tf = RigidTransform.from_matrix(xp.empty((0, 4, 4)))
+
+    assert tf.apply(xp.zeros((3,))).shape == (0, 3)
+    assert tf.apply(xp.empty((0, 3))).shape == (0, 3)
+
+    with pytest.raises(ValueError, match="operands could not be broadcast together"):
+        tf.apply(xp.zeros((2, 3)))
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"), (RigidTransform, "__mul__"))
+def test_empty_transform_composition(xp):
+    tf_empty = RigidTransform.from_matrix(xp.empty((0, 4, 4)))
+    tf_single = RigidTransform.from_matrix(xp.eye(4))
+    tf_many = rigid_transform_to_xp(RigidTransform.identity(3), xp=xp)
+
+    assert len(tf_empty * tf_empty) == 0
+    assert len(tf_empty * tf_single) == 0
+    assert len(tf_single * tf_empty) == 0
+
+    with pytest.raises(ValueError, match="Cannot broadcast"):
+        tf_many * tf_empty
+
+    with pytest.raises(ValueError, match="Cannot broadcast"):
+        tf_empty * tf_many
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"), (RigidTransform, "concatenate"))
+def test_empty_transform_concatenation(xp):
+    tf_empty = RigidTransform.from_matrix(xp.empty((0, 4, 4)))
+    tf_single = RigidTransform.from_matrix(xp.eye(4))
+    tf_many = rigid_transform_to_xp(RigidTransform.identity(2), xp=xp)
+
+    assert len(RigidTransform.concatenate([tf_empty, tf_empty])) == 0
+    assert len(RigidTransform.concatenate([tf_empty, tf_single])) == 1
+    assert len(RigidTransform.concatenate([tf_single, tf_empty])) == 1
+    assert len(RigidTransform.concatenate([tf_empty, tf_many])) == 2
+    assert len(RigidTransform.concatenate([tf_many, tf_empty])) == 2
+    assert len(RigidTransform.concatenate([tf_many, tf_empty, tf_single])) == 3
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"), (RigidTransform, "inv"),
+                   (RigidTransform, "__pow__"))
+def test_empty_transform_inv_and_pow(xp):
+    tf = RigidTransform.from_matrix(xp.empty((0, 4, 4)))
+    assert len(tf.inv()) == 0
+    assert len(tf ** 0) == 0
+    assert len(tf ** 1) == 0
+    assert len(tf ** -1) == 0
+    assert len(tf ** 0.5) == 0
+
+
+@make_xp_test_case((RigidTransform, "__getitem__"))
+def test_empty_transform_indexing(xp):
+    tf_many = rigid_transform_to_xp(RigidTransform.identity(3), xp=xp)
+    tf_zero = tf_many[xp.asarray([], dtype=xp.int32)]
+    assert len(tf_zero) == 0
+
+    # Array API does not specify out-of-bounds indexing. Only check for numpy.
+    if is_numpy(xp):
+        assert len(tf_zero[:5]) == 0  # Slices can go out of bounds.
+
+    with pytest.raises(IndexError):
+        tf_zero[0]
+
+    with pytest.raises(IndexError):
+        tf_zero[xp.asarray([0, 2])]
+
+    with pytest.raises(IndexError):
+        tf_zero[xp.asarray([False, True])]
+
+
+@make_xp_test_case((RigidTransform, "from_matrix"))
+@pytest.mark.skip_xp_backends("array_api_strict",
+                              reason="array API doesn't support pickling")
+def test_pickling(xp):
+    # Note: Array API makes no provision for arrays to be pickleable, so
+    # it's OK to skip this test for the backends that don't support it
+    mat = xp.eye(4)
+    mat = xpx.at(mat)[0, 3].set(2.0)
+    tf = RigidTransform.from_matrix(mat)
+    pkl = pickle.dumps(tf)
+    unpickled = pickle.loads(pkl)
+    xp_assert_close(tf.as_matrix(), unpickled.as_matrix(), atol=1e-15)
+
+
+@make_xp_test_case(
+    (RigidTransform, "as_matrix"),
+    (RigidTransform, "__iter__"),
+    (RigidTransform, "identity"),
+)
+def test_rigid_transform_iter(xp):
+    r = rigid_transform_to_xp(RigidTransform.identity(3), xp)
+    for i, r_i in enumerate(r):
+        assert isinstance(r_i, RigidTransform)
+        xp_assert_equal(r_i.as_matrix(), r[i].as_matrix())
+        if i > len(r):
+            raise RuntimeError("Iteration exceeded length of transforms")
+
+
+@make_xp_test_case((RigidTransform, "from_translation"))
+@pytest.mark.parametrize("dim", range(1, 5))
+def test_shape_property(xp, dim: int):
+    shape = (dim,) * (dim - 1)
+    tf = RigidTransform.from_translation(xp.zeros(shape + (3,)))
+    assert tf.shape == shape
+
+
+def test_non_writeable():
+    mat = np.eye(4)
+    mat.flags.writeable = False
+    RigidTransform.from_matrix(mat)  # Regression test against gh-24378

v12x/pylib/scipy/spatial/transform/tests/test_rotation_groups.py

@@ -0,0 +1,169 @@
+import pytest
+
+import numpy as np
+from numpy.testing import assert_array_almost_equal
+from scipy.spatial.transform import Rotation
+from scipy.optimize import linear_sum_assignment
+from scipy.spatial.distance import cdist
+from scipy.constants import golden as phi
+from scipy.spatial import cKDTree
+
+
+TOL = 1E-12
+NS = list(range(1, 13))
+NAMES = ["I", "O", "T"] + [f"C{n}" for n in NS] + [f"D{n}" for n in NS]
+SIZES = [60, 24, 12] + list(NS) + [2 * n for n in NS]
+
+
+def _calculate_rmsd(P, Q):
+    """Calculates the root-mean-square distance between the points of P and Q.
+    The distance is taken as the minimum over all possible matchings. It is
+    zero if P and Q are identical and non-zero if not.
+    """
+    distance_matrix = cdist(P, Q, metric='sqeuclidean')
+    matching = linear_sum_assignment(distance_matrix)
+    return np.sqrt(distance_matrix[matching].sum())
+
+
+def _generate_pyramid(n, axis):
+    thetas = np.linspace(0, 2 * np.pi, n + 1)[:-1]
+    P = np.vstack([np.zeros(n), np.cos(thetas), np.sin(thetas)]).T
+    P = np.concatenate((P, [[1, 0, 0]]))
+    return np.roll(P, axis, axis=1)
+
+
+def _generate_prism(n, axis):
+    thetas = np.linspace(0, 2 * np.pi, n + 1)[:-1]
+    bottom = np.vstack([-np.ones(n), np.cos(thetas), np.sin(thetas)]).T
+    top = np.vstack([+np.ones(n), np.cos(thetas), np.sin(thetas)]).T
+    P = np.concatenate((bottom, top))
+    return np.roll(P, axis, axis=1)
+
+
+def _generate_icosahedron():
+    x = np.array([[0, -1, -phi],
+                  [0, -1, +phi],
+                  [0, +1, -phi],
+                  [0, +1, +phi]])
+    return np.concatenate([np.roll(x, i, axis=1) for i in range(3)])
+
+
+def _generate_octahedron():
+    return np.array([[-1, 0, 0], [+1, 0, 0], [0, -1, 0],
+                     [0, +1, 0], [0, 0, -1], [0, 0, +1]])
+
+
+def _generate_tetrahedron():
+    return np.array([[1, 1, 1], [1, -1, -1], [-1, 1, -1], [-1, -1, 1]])
+
+
+@pytest.mark.parametrize("name", [-1, None, True, np.array(['C3'])])
+def test_group_type(name):
+    with pytest.raises(ValueError,
+                       match="must be a string"):
+        Rotation.create_group(name)
+
+
+@pytest.mark.parametrize("name", ["Q", " ", "CA", "C ", "DA", "D ", "I2", ""])
+def test_group_name(name):
+    with pytest.raises(ValueError,
+                       match="must be one of 'I', 'O', 'T', 'Dn', 'Cn'"):
+        Rotation.create_group(name)
+
+
+@pytest.mark.parametrize("name", ["C0", "D0"])
+def test_group_order_positive(name):
+    with pytest.raises(ValueError,
+                       match="Group order must be positive"):
+        Rotation.create_group(name)
+
+
+@pytest.mark.parametrize("axis", ['A', 'b', 0, 1, 2, 4, False, None])
+def test_axis_valid(axis):
+    with pytest.raises(ValueError,
+                       match="`axis` must be one of"):
+        Rotation.create_group("C1", axis)
+
+
+def test_icosahedral():
+    """The icosahedral group fixes the rotations of an icosahedron. Here we
+    test that the icosahedron is invariant after application of the elements
+    of the rotation group."""
+    P = _generate_icosahedron()
+    for g in Rotation.create_group("I"):
+        g = Rotation.from_quat(g.as_quat())
+        assert _calculate_rmsd(P, g.apply(P)) < TOL
+
+
+def test_octahedral():
+    """Test that the octahedral group correctly fixes the rotations of an
+    octahedron."""
+    P = _generate_octahedron()
+    for g in Rotation.create_group("O"):
+        assert _calculate_rmsd(P, g.apply(P)) < TOL
+
+
+def test_tetrahedral():
+    """Test that the tetrahedral group correctly fixes the rotations of a
+    tetrahedron."""
+    P = _generate_tetrahedron()
+    for g in Rotation.create_group("T"):
+        assert _calculate_rmsd(P, g.apply(P)) < TOL
+
+
+@pytest.mark.parametrize("n", NS)
+@pytest.mark.parametrize("axis", 'XYZ')
+def test_dicyclic(n, axis):
+    """Test that the dicyclic group correctly fixes the rotations of a
+    prism."""
+    P = _generate_prism(n, axis='XYZ'.index(axis))
+    for g in Rotation.create_group(f"D{n}", axis=axis):
+        assert _calculate_rmsd(P, g.apply(P)) < TOL
+
+
+@pytest.mark.parametrize("n", NS)
+@pytest.mark.parametrize("axis", 'XYZ')
+def test_cyclic(n, axis):
+    """Test that the cyclic group correctly fixes the rotations of a
+    pyramid."""
+    P = _generate_pyramid(n, axis='XYZ'.index(axis))
+    for g in Rotation.create_group(f"C{n}", axis=axis):
+        assert _calculate_rmsd(P, g.apply(P)) < TOL
+
+
+@pytest.mark.parametrize("name, size", list(zip(NAMES, SIZES)))
+def test_group_sizes(name, size):
+    assert len(Rotation.create_group(name)) == size
+
+
+@pytest.mark.parametrize("name, size", list(zip(NAMES, SIZES)))
+def test_group_no_duplicates(name, size):
+    g = Rotation.create_group(name)
+    kdtree = cKDTree(g.as_quat())
+    assert len(kdtree.query_pairs(1E-3)) == 0
+
+
+@pytest.mark.parametrize("name, size", list(zip(NAMES, SIZES)))
+def test_group_symmetry(name, size):
+    g = Rotation.create_group(name)
+    q = np.concatenate((-g.as_quat(), g.as_quat()))
+    distance = np.sort(cdist(q, q))
+    deltas = np.max(distance, axis=0) - np.min(distance, axis=0)
+    assert (deltas < TOL).all()
+
+
+@pytest.mark.parametrize("name", NAMES)
+def test_reduction(name):
+    """Test that the elements of the rotation group are correctly
+    mapped onto the identity rotation."""
+    g = Rotation.create_group(name)
+    f = g.reduce(g)
+    assert_array_almost_equal(f.magnitude(), np.zeros(len(g)))
+
+
+@pytest.mark.parametrize("name", NAMES)
+def test_single_reduction(name):
+    g = Rotation.create_group(name)
+    f = g[-1].reduce(g)
+    assert_array_almost_equal(f.magnitude(), 0)
+    assert f.as_quat().shape == (4,)

v12x/pylib/scipy/spatial/transform/tests/test_rotation_spline.py

@@ -0,0 +1,188 @@
+from itertools import product
+import numpy as np
+from numpy.testing import assert_allclose
+import pytest
+from scipy.spatial.transform import Rotation, RotationSpline
+from scipy.spatial.transform._rotation_spline import (
+    _angular_rate_to_rotvec_dot_matrix,
+    _rotvec_dot_to_angular_rate_matrix,
+    _matrix_vector_product_of_stacks,
+    _angular_acceleration_nonlinear_term,
+    _create_block_3_diagonal_matrix)
+
+
+pytestmark = pytest.mark.skip_xp_backends(np_only=True)
+
+
+def test_angular_rate_to_rotvec_conversions():
+    np.random.seed(0)
+    rv = np.random.randn(4, 3)
+    A = _angular_rate_to_rotvec_dot_matrix(rv)
+    A_inv = _rotvec_dot_to_angular_rate_matrix(rv)
+
+    # When the rotation vector is aligned with the angular rate, then
+    # the rotation vector rate and angular rate are the same.
+    assert_allclose(_matrix_vector_product_of_stacks(A, rv), rv)
+    assert_allclose(_matrix_vector_product_of_stacks(A_inv, rv), rv)
+
+    # A and A_inv must be reciprocal to each other.
+    I_stack = np.empty((4, 3, 3))
+    I_stack[:] = np.eye(3)
+    assert_allclose(np.matmul(A, A_inv), I_stack, atol=1e-15)
+
+
+def test_angular_rate_nonlinear_term():
+    # The only simple test is to check that the term is zero when
+    # the rotation vector
+    np.random.seed(0)
+    rv = np.random.rand(4, 3)
+    assert_allclose(_angular_acceleration_nonlinear_term(rv, rv), 0,
+                    atol=1e-19)
+
+
+def test_create_block_3_diagonal_matrix():
+    np.random.seed(0)
+    A = np.empty((4, 3, 3))
+    A[:] = np.arange(1, 5)[:, None, None]
+
+    B = np.empty((4, 3, 3))
+    B[:] = -np.arange(1, 5)[:, None, None]
+    d = 10 * np.arange(10, 15)
+
+    banded = _create_block_3_diagonal_matrix(A, B, d)
+
+    # Convert the banded matrix to the full matrix.
+    k, l = list(zip(*product(np.arange(banded.shape[0]),
+                             np.arange(banded.shape[1]))))
+    k = np.asarray(k)
+    l = np.asarray(l)
+
+    i = k - 5 + l
+    j = l
+    values = banded.ravel()
+    mask = (i >= 0) & (i < 15)
+    i = i[mask]
+    j = j[mask]
+    values = values[mask]
+    full = np.zeros((15, 15))
+    full[i, j] = values
+
+    zero = np.zeros((3, 3))
+    eye = np.eye(3)
+
+    # Create the reference full matrix in the most straightforward manner.
+    ref = np.block([
+        [d[0] * eye, B[0], zero, zero, zero],
+        [A[0], d[1] * eye, B[1], zero, zero],
+        [zero, A[1], d[2] * eye, B[2], zero],
+        [zero, zero, A[2], d[3] * eye, B[3]],
+        [zero, zero, zero, A[3], d[4] * eye],
+    ])
+
+    assert_allclose(full, ref, atol=1e-19)
+
+
+def test_spline_2_rotations():
+    times = [0, 10]
+    rotations = Rotation.from_euler('xyz', [[0, 0, 0], [10, -20, 30]],
+                                    degrees=True)
+    spline = RotationSpline(times, rotations)
+
+    rv = (rotations[0].inv() * rotations[1]).as_rotvec()
+    rate = rv / (times[1] - times[0])
+    times_check = np.array([-1, 5, 12])
+    dt = times_check - times[0]
+    rv_ref = rate * dt[:, None]
+
+    assert_allclose(spline(times_check).as_rotvec(), rv_ref)
+    assert_allclose(spline(times_check, 1), np.resize(rate, (3, 3)))
+    assert_allclose(spline(times_check, 2), 0, atol=1e-16)
+
+
+def test_constant_attitude():
+    times = np.arange(10)
+    rotations = Rotation.from_rotvec(np.ones((10, 3)))
+    spline = RotationSpline(times, rotations)
+
+    times_check = np.linspace(-1, 11)
+    assert_allclose(spline(times_check).as_rotvec(), 1, rtol=1e-15)
+    assert_allclose(spline(times_check, 1), 0, atol=1e-17)
+    assert_allclose(spline(times_check, 2), 0, atol=1e-17)
+
+    assert_allclose(spline(5.5).as_rotvec(), 1, rtol=1e-15)
+    assert_allclose(spline(5.5, 1), 0, atol=1e-17)
+    assert_allclose(spline(5.5, 2), 0, atol=1e-17)
+
+
+def test_spline_properties():
+    times = np.array([0, 5, 15, 27])
+    angles = [[-5, 10, 27], [3, 5, 38], [-12, 10, 25], [-15, 20, 11]]
+
+    rotations = Rotation.from_euler('xyz', angles, degrees=True)
+    spline = RotationSpline(times, rotations)
+
+    assert_allclose(spline(times).as_euler('xyz', degrees=True), angles)
+    assert_allclose(spline(0).as_euler('xyz', degrees=True), angles[0])
+
+    h = 1e-8
+    rv0 = spline(times).as_rotvec()
+    rvm = spline(times - h).as_rotvec()
+    rvp = spline(times + h).as_rotvec()
+    # rtol bumped from 1e-15 to 1.5e-15 in gh18414 for linux 32 bit
+    assert_allclose(rv0, 0.5 * (rvp + rvm), rtol=1.5e-15)
+
+    r0 = spline(times, 1)
+    rm = spline(times - h, 1)
+    rp = spline(times + h, 1)
+    assert_allclose(r0, 0.5 * (rm + rp), rtol=1e-14)
+
+    a0 = spline(times, 2)
+    am = spline(times - h, 2)
+    ap = spline(times + h, 2)
+    assert_allclose(a0, am, rtol=1e-7)
+    assert_allclose(a0, ap, rtol=1e-7)
+
+
+def test_error_handling():
+    with pytest.raises(ValueError):
+        RotationSpline([1.0], Rotation.random())
+
+    r = Rotation.random(10)
+    t = np.arange(10).reshape(5, 2)
+    with pytest.raises(ValueError):
+        RotationSpline(t, r)
+
+    t = np.arange(9)
+    with pytest.raises(ValueError):
+        RotationSpline(t, r)
+
+    t = np.arange(10)
+    t[5] = 0
+    with pytest.raises(ValueError):
+        RotationSpline(t, r)
+
+    t = np.arange(10)
+
+    s = RotationSpline(t, r)
+    with pytest.raises(ValueError):
+        s(10, -1)
+
+    with pytest.raises(ValueError):
+        s(np.arange(10).reshape(5, 2))
+
+    r = Rotation.from_quat(np.array([[[0.0, 0, 0, 1], [1, 0, 0 ,0]]]))
+    t = np.arange(2)
+    with pytest.raises(ValueError):
+        RotationSpline(t, r)  # More than 2 dimensions
+
+
+@pytest.mark.skip_xp_backends("numpy")
+def test_xp_errors(xp):
+    times = xp.asarray([0, 10])
+    r = Rotation.random(2)
+    r = Rotation.from_quat(xp.asarray(r.as_quat()))
+    s = RotationSpline(times, r)
+    t = xp.asarray([0.5, 1.5])
+    # RotationSpline does not have native Array API support, so we check that it
+    # converts any array to NumPy and outputs NumPy arrays.
+    assert isinstance(s(t).as_quat(), np.ndarray)

v12x/pylib/scipy/special/__init__.py

@@ -0,0 +1,842 @@
+"""
+========================================
+Special functions (:mod:`scipy.special`)
+========================================
+
+.. currentmodule:: scipy.special
+
+.. toctree::
+   :hidden:
+
+   special.cython_special
+
+Almost all of the functions below accept NumPy arrays as input
+arguments as well as single numbers. This means they follow
+broadcasting and automatic array-looping rules. Technically,
+they are `NumPy universal functions
+<https://numpy.org/doc/stable/user/basics.ufuncs.html#ufuncs-basics>`_.
+Functions which do not accept NumPy arrays are marked by a warning
+in the section description.
+
+.. seealso::
+
+   `scipy.special.cython_special` -- Typed Cython versions of special functions
+
+
+Error handling
+==============
+
+Errors are handled by returning NaNs or other appropriate values.
+Some of the special function routines can emit warnings or raise
+exceptions when an error occurs. By default this is disabled, except
+for memory allocation errors, which result in an exception being raised.
+To query and control the current error handling state the following
+functions are provided.
+
+.. autosummary::
+   :toctree: generated/
+
+   geterr                 -- Get the current way of handling special-function errors.
+   seterr                 -- Set how special-function errors are handled.
+   errstate               -- Context manager for special-function error handling.
+   SpecialFunctionWarning -- Warning that can be emitted by special functions.
+   SpecialFunctionError   -- Exception that can be raised by special functions.
+
+Available functions
+===================
+
+Airy functions
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   airy     -- Airy functions and their derivatives.
+   airye    -- Exponentially scaled Airy functions and their derivatives.
+   ai_zeros -- Compute `nt` zeros and values of the Airy function Ai and its derivative.
+   bi_zeros -- Compute `nt` zeros and values of the Airy function Bi and its derivative.
+   itairy   -- Integrals of Airy functions
+
+
+Elliptic functions and integrals
+--------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   ellipj    -- Jacobian elliptic functions.
+   ellipk    -- Complete elliptic integral of the first kind.
+   ellipkm1  -- Complete elliptic integral of the first kind around `m` = 1.
+   ellipkinc -- Incomplete elliptic integral of the first kind.
+   ellipe    -- Complete elliptic integral of the second kind.
+   ellipeinc -- Incomplete elliptic integral of the second kind.
+   elliprc   -- Degenerate symmetric integral RC.
+   elliprd   -- Symmetric elliptic integral of the second kind.
+   elliprf   -- Completely-symmetric elliptic integral of the first kind.
+   elliprg   -- Completely-symmetric elliptic integral of the second kind.
+   elliprj   -- Symmetric elliptic integral of the third kind.
+
+Bessel functions
+----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   jv                -- Bessel function of the first kind of real order and \
+                        complex argument.
+   jve               -- Exponentially scaled Bessel function of order `v`.
+   yn                -- Bessel function of the second kind of integer order and \
+                        real argument.
+   yv                -- Bessel function of the second kind of real order and \
+                        complex argument.
+   yve               -- Exponentially scaled Bessel function of the second kind \
+                        of real order.
+   iv                -- Modified Bessel function of the first kind of real order.
+   ive               -- Exponentially scaled modified Bessel function of the \
+                        first kind.
+   kn                -- Modified Bessel function of the second kind of integer \
+                        order `n`
+   kv                -- Modified Bessel function of the second kind of real order \
+                        `v`
+   kve               -- Exponentially scaled modified Bessel function of the \
+                        second kind.
+   hankel1           -- Hankel function of the first kind.
+   hankel1e          -- Exponentially scaled Hankel function of the first kind.
+   hankel2           -- Hankel function of the second kind.
+   hankel2e          -- Exponentially scaled Hankel function of the second kind.
+   wright_bessel     -- Wright's generalized Bessel function.
+   log_wright_bessel -- Logarithm of Wright's generalized Bessel function.
+
+The following function does not accept NumPy arrays (it is not a
+universal function):
+
+.. autosummary::
+   :toctree: generated/
+
+   lmbda -- Jahnke-Emden Lambda function, Lambdav(x).
+
+Zeros of Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   jnjnp_zeros -- Compute zeros of integer-order Bessel functions Jn and Jn'.
+   jnyn_zeros  -- Compute nt zeros of Bessel functions Jn(x), Jn'(x), Yn(x), and Yn'(x).
+   jn_zeros    -- Compute zeros of integer-order Bessel function Jn(x).
+   jnp_zeros   -- Compute zeros of integer-order Bessel function derivative Jn'(x).
+   yn_zeros    -- Compute zeros of integer-order Bessel function Yn(x).
+   ynp_zeros   -- Compute zeros of integer-order Bessel function derivative Yn'(x).
+   y0_zeros    -- Compute nt zeros of Bessel function Y0(z), and derivative at each zero.
+   y1_zeros    -- Compute nt zeros of Bessel function Y1(z), and derivative at each zero.
+   y1p_zeros   -- Compute nt zeros of Bessel derivative Y1'(z), and value at each zero.
+
+Faster versions of common Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   j0  -- Bessel function of the first kind of order 0.
+   j1  -- Bessel function of the first kind of order 1.
+   y0  -- Bessel function of the second kind of order 0.
+   y1  -- Bessel function of the second kind of order 1.
+   i0  -- Modified Bessel function of order 0.
+   i0e -- Exponentially scaled modified Bessel function of order 0.
+   i1  -- Modified Bessel function of order 1.
+   i1e -- Exponentially scaled modified Bessel function of order 1.
+   k0  -- Modified Bessel function of the second kind of order 0, :math:`K_0`.
+   k0e -- Exponentially scaled modified Bessel function K of order 0
+   k1  -- Modified Bessel function of the second kind of order 1, :math:`K_1(x)`.
+   k1e -- Exponentially scaled modified Bessel function K of order 1.
+
+Integrals of Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   itj0y0     -- Integrals of Bessel functions of order 0.
+   it2j0y0    -- Integrals related to Bessel functions of order 0.
+   iti0k0     -- Integrals of modified Bessel functions of order 0.
+   it2i0k0    -- Integrals related to modified Bessel functions of order 0.
+   besselpoly -- Weighted integral of a Bessel function.
+
+Derivatives of Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   jvp  -- Compute nth derivative of Bessel function Jv(z) with respect to `z`.
+   yvp  -- Compute nth derivative of Bessel function Yv(z) with respect to `z`.
+   ivp  -- Compute nth derivative of modified Bessel function Iv(z) with respect to `z`.
+   kvp  -- Compute nth derivative of real-order modified Bessel function Kv(z)
+   h1vp -- Compute nth derivative of Hankel function H1v(z) with respect to `z`.
+   h2vp -- Compute nth derivative of Hankel function H2v(z) with respect to `z`.
+
+Spherical Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   spherical_jn -- Spherical Bessel function of the first kind or its derivative.
+   spherical_yn -- Spherical Bessel function of the second kind or its derivative.
+   spherical_in -- Modified spherical Bessel function of the first kind or its derivative.
+   spherical_kn -- Modified spherical Bessel function of the second kind or its derivative.
+
+Riccati-Bessel functions
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   riccati_jn -- Compute Riccati-Bessel function of the first kind and its derivative.
+   riccati_yn -- Compute Riccati-Bessel function of the second kind and its derivative.
+
+Struve functions
+----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   struve       -- Struve function.
+   modstruve    -- Modified Struve function.
+   itstruve0    -- Integral of the Struve function of order 0.
+   it2struve0   -- Integral related to the Struve function of order 0.
+   itmodstruve0 -- Integral of the modified Struve function of order 0.
+
+
+Raw statistical functions
+-------------------------
+
+.. seealso:: :mod:`scipy.stats`: Friendly versions of these functions.
+
+Binomial distribution
+^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   bdtr         -- Binomial distribution cumulative distribution function.
+   bdtrc        -- Binomial distribution survival function.
+   bdtri        -- Inverse function to `bdtr` with respect to `p`.
+   bdtrik       -- Inverse function to `bdtr` with respect to `k`.
+   bdtrin       -- Inverse function to `bdtr` with respect to `n`.
+
+Beta distribution
+^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   btdtria      -- Inverse of `betainc` with respect to `a`.
+   btdtrib      -- Inverse of `betainc` with respect to `b`.
+
+F distribution
+^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   fdtr         -- F cumulative distribution function.
+   fdtrc        -- F survival function.
+   fdtri        -- The `p`-th quantile of the F-distribution.
+   fdtridfd     -- Inverse to `fdtr` vs dfd.
+
+Gamma distribution
+^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   gdtr         -- Gamma distribution cumulative distribution function.
+   gdtrc        -- Gamma distribution survival function.
+   gdtria       -- Inverse of `gdtr` vs a.
+   gdtrib       -- Inverse of `gdtr` vs b.
+   gdtrix       -- Inverse of `gdtr` vs x.
+
+Negative binomial distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   nbdtr        -- Negative binomial cumulative distribution function.
+   nbdtrc       -- Negative binomial survival function.
+   nbdtri       -- Inverse of `nbdtr` vs `p`.
+   nbdtrik      -- Inverse of `nbdtr` vs `k`.
+   nbdtrin      -- Inverse of `nbdtr` vs `n`.
+
+Noncentral F distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   ncfdtr       -- Cumulative distribution function of the non-central F distribution.
+   ncfdtridfd   -- Calculate degrees of freedom (denominator) for the noncentral F-distribution.
+   ncfdtridfn   -- Calculate degrees of freedom (numerator) for the noncentral F-distribution.
+   ncfdtri      -- Inverse cumulative distribution function of the non-central F distribution.
+   ncfdtrinc    -- Calculate non-centrality parameter for non-central F distribution.
+
+Noncentral t distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   nctdtr       -- Cumulative distribution function of the non-central `t` distribution.
+   nctdtridf    -- Calculate degrees of freedom for non-central t distribution.
+   nctdtrit     -- Inverse cumulative distribution function of the non-central t distribution.
+   nctdtrinc    -- Calculate non-centrality parameter for non-central t distribution.
+
+Normal distribution
+^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   nrdtrimn     -- Calculate mean of normal distribution given other params.
+   nrdtrisd     -- Calculate standard deviation of normal distribution given other params.
+   ndtr         -- Normal cumulative distribution function.
+   log_ndtr     -- Logarithm of normal cumulative distribution function.
+   ndtri        -- Inverse of `ndtr` vs x.
+   ndtri_exp    -- Inverse of `log_ndtr` vs x.
+
+Poisson distribution
+^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   pdtr         -- Poisson cumulative distribution function.
+   pdtrc        -- Poisson survival function.
+   pdtri        -- Inverse to `pdtr` vs m.
+   pdtrik       -- Inverse to `pdtr` vs k.
+
+Student t distribution
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   stdtr        -- Student t distribution cumulative distribution function.
+   stdtridf     -- Inverse of `stdtr` vs df.
+   stdtrit      -- Inverse of `stdtr` vs `t`.
+
+Chi square distribution
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   chdtr        -- Chi square cumulative distribution function.
+   chdtrc       -- Chi square survival function.
+   chdtri       -- Inverse to `chdtrc`.
+   chdtriv      -- Inverse to `chdtr` vs `v`.
+
+Non-central chi square distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   chndtr       -- Non-central chi square cumulative distribution function.
+   chndtridf    -- Inverse to `chndtr` vs `df`.
+   chndtrinc    -- Inverse to `chndtr` vs `nc`.
+   chndtrix     -- Inverse to `chndtr` vs `x`.
+
+Kolmogorov distribution
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   smirnov      -- Kolmogorov-Smirnov complementary cumulative distribution function.
+   smirnovi     -- Inverse to `smirnov`.
+   kolmogorov   -- Complementary cumulative distribution function of Kolmogorov distribution.
+   kolmogi      -- Inverse function to `kolmogorov`.
+
+Box-Cox transformation
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   boxcox       -- Compute the Box-Cox transformation.
+   boxcox1p     -- Compute the Box-Cox transformation of 1 + `x`.
+   inv_boxcox   -- Compute the inverse of the Box-Cox transformation.
+   inv_boxcox1p -- Compute the inverse of the Box-Cox transformation.
+
+
+Sigmoidal functions
+^^^^^^^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   logit        -- Logit ufunc for ndarrays.
+   expit        -- Logistic sigmoid function.
+   log_expit    -- Logarithm of the logistic sigmoid function.
+
+Miscellaneous
+^^^^^^^^^^^^^
+
+.. autosummary::
+   :toctree: generated/
+
+   tklmbda      -- Tukey-Lambda cumulative distribution function.
+   owens_t      -- Owen's T Function.
+
+
+Information Theory functions
+----------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   entr         -- Elementwise function for computing entropy.
+   rel_entr     -- Elementwise function for computing relative entropy.
+   kl_div       -- Elementwise function for computing Kullback-Leibler divergence.
+   huber        -- Huber loss function.
+   pseudo_huber -- Pseudo-Huber loss function.
+
+
+Gamma and related functions
+---------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   gamma        -- Gamma function.
+   gammaln      -- Logarithm of the absolute value of the Gamma function for real inputs.
+   loggamma     -- Principal branch of the logarithm of the Gamma function.
+   gammasgn     -- Sign of the gamma function.
+   gammainc     -- Regularized lower incomplete gamma function.
+   gammaincinv  -- Inverse to `gammainc`.
+   gammaincc    -- Regularized upper incomplete gamma function.
+   gammainccinv -- Inverse to `gammaincc`.
+   beta         -- Beta function.
+   betaln       -- Natural logarithm of absolute value of beta function.
+   betainc      -- Incomplete beta integral.
+   betaincc     -- Complemented incomplete beta integral.
+   betaincinv   -- Inverse function to beta integral.
+   betainccinv  -- Inverse of the complemented incomplete beta integral.
+   psi          -- The digamma function.
+   rgamma       -- Gamma function inverted.
+   polygamma    -- Polygamma function n.
+   multigammaln -- Returns the log of multivariate gamma, also sometimes called the generalized gamma.
+   digamma      -- psi(x[, out]).
+   poch         -- Rising factorial (z)_m.
+
+Error function and Fresnel integrals
+------------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   erf           -- Returns the error function of complex argument.
+   erfc          -- Complementary error function, ``1 - erf(x)``.
+   erfcx         -- Scaled complementary error function, ``exp(x**2) * erfc(x)``.
+   erfi          -- Imaginary error function, ``-i erf(i z)``.
+   erfinv        -- Inverse function for erf.
+   erfcinv       -- Inverse function for erfc.
+   wofz          -- Faddeeva function.
+   dawsn         -- Dawson's integral.
+   fresnel       -- Fresnel sin and cos integrals.
+   fresnel_zeros -- Compute nt complex zeros of sine and cosine Fresnel integrals S(z) and C(z).
+   modfresnelp   -- Modified Fresnel positive integrals.
+   modfresnelm   -- Modified Fresnel negative integrals.
+   voigt_profile -- Voigt profile.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   erf_zeros      -- Compute nt complex zeros of error function erf(z).
+   fresnelc_zeros -- Compute nt complex zeros of cosine Fresnel integral C(z).
+   fresnels_zeros -- Compute nt complex zeros of sine Fresnel integral S(z).
+
+Legendre functions
+------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   legendre_p                 -- Legendre polynomials of the first kind.
+   legendre_p_all             -- All Legendre polynomials of the first kind up to a specified order.
+   assoc_legendre_p           -- Associated Legendre polynomials of the first kind.
+   assoc_legendre_p_all       -- All associated Legendre polynomials of the first kind up to a specified order and degree.
+   sph_legendre_p             -- Spherical Legendre polynomials of the first kind.
+   sph_legendre_p_all         -- All spherical Legendre polynomials of the first kind up to a specified order and degree.
+   sph_harm_y                 -- Spherical harmonics.
+   sph_harm_y_all             -- All spherical harmonics up to a specified order and degree.
+
+The following functions are in the process of being deprecated in favor of the above,
+which provide a more flexible and consistent interface.
+
+.. autosummary::
+   :toctree: generated/
+
+   lpmv                       -- Associated Legendre function of integer order and real degree.
+   lqn                        -- Legendre function of the second kind.
+   lqmn                       -- Sequence of associated Legendre functions of the second kind.
+
+Ellipsoidal harmonics
+---------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   ellip_harm   -- Ellipsoidal harmonic functions E^p_n(l).
+   ellip_harm_2 -- Ellipsoidal harmonic functions F^p_n(l).
+   ellip_normal -- Ellipsoidal harmonic normalization constants gamma^p_n.
+
+Orthogonal polynomials
+----------------------
+
+The following functions evaluate values of orthogonal polynomials:
+
+.. autosummary::
+   :toctree: generated/
+
+   assoc_laguerre   -- Compute the generalized (associated) Laguerre polynomial of degree n and order k.
+   eval_legendre    -- Evaluate Legendre polynomial at a point.
+   eval_chebyt      -- Evaluate Chebyshev polynomial of the first kind at a point.
+   eval_chebyu      -- Evaluate Chebyshev polynomial of the second kind at a point.
+   eval_chebyc      -- Evaluate Chebyshev polynomial of the first kind on [-2, 2] at a point.
+   eval_chebys      -- Evaluate Chebyshev polynomial of the second kind on [-2, 2] at a point.
+   eval_jacobi      -- Evaluate Jacobi polynomial at a point.
+   eval_laguerre    -- Evaluate Laguerre polynomial at a point.
+   eval_genlaguerre -- Evaluate generalized Laguerre polynomial at a point.
+   eval_hermite     -- Evaluate physicist's Hermite polynomial at a point.
+   eval_hermitenorm -- Evaluate probabilist's (normalized) Hermite polynomial at a point.
+   eval_gegenbauer  -- Evaluate Gegenbauer polynomial at a point.
+   eval_sh_legendre -- Evaluate shifted Legendre polynomial at a point.
+   eval_sh_chebyt   -- Evaluate shifted Chebyshev polynomial of the first kind at a point.
+   eval_sh_chebyu   -- Evaluate shifted Chebyshev polynomial of the second kind at a point.
+   eval_sh_jacobi   -- Evaluate shifted Jacobi polynomial at a point.
+
+The following functions compute roots and quadrature weights for
+orthogonal polynomials:
+
+.. autosummary::
+   :toctree: generated/
+
+   roots_legendre    -- Gauss-Legendre quadrature.
+   roots_chebyt      -- Gauss-Chebyshev (first kind) quadrature.
+   roots_chebyu      -- Gauss-Chebyshev (second kind) quadrature.
+   roots_chebyc      -- Gauss-Chebyshev (first kind) quadrature.
+   roots_chebys      -- Gauss-Chebyshev (second kind) quadrature.
+   roots_jacobi      -- Gauss-Jacobi quadrature.
+   roots_laguerre    -- Gauss-Laguerre quadrature.
+   roots_genlaguerre -- Gauss-generalized Laguerre quadrature.
+   roots_hermite     -- Gauss-Hermite (physicist's) quadrature.
+   roots_hermitenorm -- Gauss-Hermite (statistician's) quadrature.
+   roots_gegenbauer  -- Gauss-Gegenbauer quadrature.
+   roots_sh_legendre -- Gauss-Legendre (shifted) quadrature.
+   roots_sh_chebyt   -- Gauss-Chebyshev (first kind, shifted) quadrature.
+   roots_sh_chebyu   -- Gauss-Chebyshev (second kind, shifted) quadrature.
+   roots_sh_jacobi   -- Gauss-Jacobi (shifted) quadrature.
+
+The functions below, in turn, return the polynomial coefficients in
+``orthopoly1d`` objects, which function similarly as `numpy.poly1d`.
+The ``orthopoly1d`` class also has an attribute ``weights``, which returns
+the roots, weights, and total weights for the appropriate form of Gaussian
+quadrature. These are returned in an ``n x 3`` array with roots in the first
+column, weights in the second column, and total weights in the final column.
+Note that ``orthopoly1d`` objects are converted to `~numpy.poly1d` when doing
+arithmetic, and lose information of the original orthogonal polynomial.
+
+.. autosummary::
+   :toctree: generated/
+
+   legendre    -- Legendre polynomial.
+   chebyt      -- Chebyshev polynomial of the first kind.
+   chebyu      -- Chebyshev polynomial of the second kind.
+   chebyc      -- Chebyshev polynomial of the first kind on :math:`[-2, 2]`.
+   chebys      -- Chebyshev polynomial of the second kind on :math:`[-2, 2]`.
+   jacobi      -- Jacobi polynomial.
+   laguerre    -- Laguerre polynomial.
+   genlaguerre -- Generalized (associated) Laguerre polynomial.
+   hermite     -- Physicist's Hermite polynomial.
+   hermitenorm -- Normalized (probabilist's) Hermite polynomial.
+   gegenbauer  -- Gegenbauer (ultraspherical) polynomial.
+   sh_legendre -- Shifted Legendre polynomial.
+   sh_chebyt   -- Shifted Chebyshev polynomial of the first kind.
+   sh_chebyu   -- Shifted Chebyshev polynomial of the second kind.
+   sh_jacobi   -- Shifted Jacobi polynomial.
+
+.. warning::
+
+   Computing values of high-order polynomials (around ``order > 20``) using
+   polynomial coefficients is numerically unstable. To evaluate polynomial
+   values, the ``eval_*`` functions should be used instead.
+
+
+Hypergeometric functions
+------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   hyp2f1 -- Gauss hypergeometric function 2F1(a, b; c; z).
+   hyp1f1 -- Confluent hypergeometric function 1F1(a, b; x).
+   hyperu -- Confluent hypergeometric function U(a, b, x) of the second kind.
+   hyp0f1 -- Confluent hypergeometric limit function 0F1.
+
+
+Parabolic cylinder functions
+----------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   pbdv -- Parabolic cylinder function D.
+   pbvv -- Parabolic cylinder function V.
+   pbwa -- Parabolic cylinder function W.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   pbdv_seq -- Parabolic cylinder functions Dv(x) and derivatives.
+   pbvv_seq -- Parabolic cylinder functions Vv(x) and derivatives.
+   pbdn_seq -- Parabolic cylinder functions Dn(z) and derivatives.
+
+Mathieu and related functions
+-----------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   mathieu_a -- Characteristic value of even Mathieu functions.
+   mathieu_b -- Characteristic value of odd Mathieu functions.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   mathieu_even_coef -- Fourier coefficients for even Mathieu and modified Mathieu functions.
+   mathieu_odd_coef  -- Fourier coefficients for even Mathieu and modified Mathieu functions.
+
+The following return both function and first derivative:
+
+.. autosummary::
+   :toctree: generated/
+
+   mathieu_cem     -- Even Mathieu function and its derivative.
+   mathieu_sem     -- Odd Mathieu function and its derivative.
+   mathieu_modcem1 -- Even modified Mathieu function of the first kind and its derivative.
+   mathieu_modcem2 -- Even modified Mathieu function of the second kind and its derivative.
+   mathieu_modsem1 -- Odd modified Mathieu function of the first kind and its derivative.
+   mathieu_modsem2 -- Odd modified Mathieu function of the second kind and its derivative.
+
+Spheroidal wave functions
+-------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   pro_ang1   -- Prolate spheroidal angular function of the first kind and its derivative.
+   pro_rad1   -- Prolate spheroidal radial function of the first kind and its derivative.
+   pro_rad2   -- Prolate spheroidal radial function of the second kind and its derivative.
+   obl_ang1   -- Oblate spheroidal angular function of the first kind and its derivative.
+   obl_rad1   -- Oblate spheroidal radial function of the first kind and its derivative.
+   obl_rad2   -- Oblate spheroidal radial function of the second kind and its derivative.
+   pro_cv     -- Characteristic value of prolate spheroidal function.
+   obl_cv     -- Characteristic value of oblate spheroidal function.
+   pro_cv_seq -- Characteristic values for prolate spheroidal wave functions.
+   obl_cv_seq -- Characteristic values for oblate spheroidal wave functions.
+
+The following functions require pre-computed characteristic value:
+
+.. autosummary::
+   :toctree: generated/
+
+   pro_ang1_cv -- Prolate spheroidal angular function pro_ang1 for precomputed characteristic value.
+   pro_rad1_cv -- Prolate spheroidal radial function pro_rad1 for precomputed characteristic value.
+   pro_rad2_cv -- Prolate spheroidal radial function pro_rad2 for precomputed characteristic value.
+   obl_ang1_cv -- Oblate spheroidal angular function obl_ang1 for precomputed characteristic value.
+   obl_rad1_cv -- Oblate spheroidal radial function obl_rad1 for precomputed characteristic value.
+   obl_rad2_cv -- Oblate spheroidal radial function obl_rad2 for precomputed characteristic value.
+
+Kelvin functions
+----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   kelvin       -- Kelvin functions as complex numbers.
+   kelvin_zeros -- Compute nt zeros of all Kelvin functions.
+   ber          -- Kelvin function ber.
+   bei          -- Kelvin function bei
+   berp         -- Derivative of the Kelvin function `ber`.
+   beip         -- Derivative of the Kelvin function `bei`.
+   ker          -- Kelvin function ker.
+   kei          -- Kelvin function ker.
+   kerp         -- Derivative of the Kelvin function ker.
+   keip         -- Derivative of the Kelvin function kei.
+
+The following functions do not accept NumPy arrays (they are not
+universal functions):
+
+.. autosummary::
+   :toctree: generated/
+
+   ber_zeros  -- Compute nt zeros of the Kelvin function ber(x).
+   bei_zeros  -- Compute nt zeros of the Kelvin function bei(x).
+   berp_zeros -- Compute nt zeros of the Kelvin function ber'(x).
+   beip_zeros -- Compute nt zeros of the Kelvin function bei'(x).
+   ker_zeros  -- Compute nt zeros of the Kelvin function ker(x).
+   kei_zeros  -- Compute nt zeros of the Kelvin function kei(x).
+   kerp_zeros -- Compute nt zeros of the Kelvin function ker'(x).
+   keip_zeros -- Compute nt zeros of the Kelvin function kei'(x).
+
+Combinatorics
+-------------
+
+.. autosummary::
+   :toctree: generated/
+
+   comb -- The number of combinations of N things taken k at a time.
+   perm -- Permutations of N things taken k at a time, i.e., k-permutations of N.
+   stirling2 -- Stirling numbers of the second kind.
+
+Lambert W and related functions
+-------------------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   lambertw    -- Lambert W function.
+   wrightomega -- Wright Omega function.
+
+Other special functions
+-----------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   agm         -- Arithmetic, Geometric Mean.
+   bernoulli   -- Bernoulli numbers B0..Bn (inclusive).
+   binom       -- Binomial coefficient
+   diric       -- Periodic sinc function, also called the Dirichlet kernel.
+   euler       -- Euler numbers E0..En (inclusive).
+   expn        -- Exponential integral E_n.
+   exp1        -- Exponential integral E_1 of complex argument z.
+   expi        -- Exponential integral Ei.
+   factorial   -- The factorial of a number or array of numbers.
+   factorial2  -- Double factorial.
+   factorialk  -- Multifactorial of n of order k, n(!!...!).
+   shichi      -- Hyperbolic sine and cosine integrals.
+   sici        -- Sine and cosine integrals.
+   softmax     -- Softmax function.
+   log_softmax -- Logarithm of softmax function.
+   spence      -- Spence's function, also known as the dilogarithm.
+   zeta        -- Riemann zeta function.
+   zetac       -- Riemann zeta function minus 1.
+   softplus    -- Softplus function.
+
+Convenience functions
+---------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   cbrt      -- Cube root of `x`.
+   exp10     -- 10**x.
+   exp2      -- 2**x.
+   radian    -- Convert from degrees to radians.
+   cosdg     -- Cosine of the angle `x` given in degrees.
+   sindg     -- Sine of angle given in degrees.
+   tandg     -- Tangent of angle x given in degrees.
+   cotdg     -- Cotangent of the angle `x` given in degrees.
+   log1p     -- Calculates log(1+x) for use when `x` is near zero.
+   expm1     -- ``exp(x) - 1`` for use when `x` is near zero.
+   cosm1     -- ``cos(x) - 1`` for use when `x` is near zero.
+   powm1     -- ``x**y - 1`` for use when `y` is near zero or `x` is near 1.
+   round     -- Round to nearest integer.
+   xlogy     -- Compute ``x*log(y)`` so that the result is 0 if ``x = 0``.
+   xlog1py   -- Compute ``x*log1p(y)`` so that the result is 0 if ``x = 0``.
+   logsumexp -- Compute the log of the sum of exponentials of input elements.
+   exprel    -- Relative error exponential, (exp(x)-1)/x, for use when `x` is near zero.
+   sinc      -- Return the sinc function.
+
+"""  # noqa: E501
+
+
+from ._sf_error import SpecialFunctionWarning, SpecialFunctionError
+
+from . import _ufuncs
+from ._ufuncs import *
+
+from . import _basic
+from ._basic import *
+
+# Replace some function definitions from _ufuncs and _basic
+# to add Array API support
+from ._support_alternative_backends import *
+
+from ._logsumexp import logsumexp, softmax, log_softmax
+
+from . import _multiufuncs
+from ._multiufuncs import *
+
+from . import _orthogonal
+from ._orthogonal import *
+
+from ._ellip_harm import (
+    ellip_harm,
+    ellip_harm_2,
+    ellip_normal
+)
+from ._lambertw import lambertw
+from ._spherical_bessel import (
+    spherical_jn,
+    spherical_yn,
+    spherical_in,
+    spherical_kn
+)
+
+# Deprecated namespaces, to be removed in v2.0.0
+from . import add_newdocs, basic, orthogonal, specfun, sf_error, spfun_stats
+
+# We replace some function definitions from _ufuncs with those from
+# _support_alternative_backends above, but those are all listed in _ufuncs.__all__,
+# so there is no need to consider _support_alternative_backends.__all__ here.
+__all__ = _ufuncs.__all__ + _basic.__all__ + _orthogonal.__all__ + _multiufuncs.__all__
+__all__ += [
+    'SpecialFunctionWarning',
+    'SpecialFunctionError',
+    'logsumexp',
+    'softmax',
+    'log_softmax',
+    'multigammaln',  # pyrefly:ignore[bad-dunder-all]
+    'ellip_harm',
+    'ellip_harm_2',
+    'ellip_normal',
+    'lambertw',
+    'spherical_jn',
+    'spherical_yn',
+    'spherical_in',
+    'spherical_kn',
+]
+
+from scipy._lib._testutils import PytestTester
+test = PytestTester(__name__)
+del PytestTester

v12x/pylib/scipy/special/_ellip_harm.py

@@ -0,0 +1,214 @@
+import numpy as np
+
+from ._ufuncs import _ellip_harm
+from ._ellip_harm_2 import _ellipsoid, _ellipsoid_norm
+
+
+def ellip_harm(h2, k2, n, p, s, signm=1, signn=1):
+    r"""
+    Ellipsoidal harmonic functions E^p_n(l).
+
+    These are also known as Lamé functions of the first kind, and are
+    solutions to the Lamé equation:
+
+    .. math:: (s^2 - h^2)(s^2 - k^2)E''(s)
+              + s(2s^2 - h^2 - k^2)E'(s) + (a - q s^2)E(s) = 0
+
+    where :math:`q = (n+1)n` and :math:`a` is the eigenvalue (not
+    returned) corresponding to the solutions.
+
+    Parameters
+    ----------
+    h2 : float
+        ``h**2``
+    k2 : float
+        ``k**2``; should be larger than ``h**2``
+    n : int
+        Degree
+    p : int
+        Order, can range between ``[1, 2n+1]``
+    s : float
+        Coordinate
+    signm : {1, -1}, optional
+        Sign of prefactor of functions. Can be +/-1. See Notes.
+    signn : {1, -1}, optional
+        Sign of prefactor of functions. Can be +/-1. See Notes.
+
+    Returns
+    -------
+    E : float
+        the harmonic :math:`E^p_n(s)`
+
+    See Also
+    --------
+    ellip_harm_2, ellip_normal
+
+    Notes
+    -----
+    The geometric interpretation of the ellipsoidal functions is
+    explained in [2]_, [3]_, [4]_. The `signm` and `signn` arguments control the
+    sign of prefactors for functions according to their type::
+
+        K : +1
+        L : signm
+        M : signn
+        N : signm*signn
+
+    .. versionadded:: 0.15.0
+
+    References
+    ----------
+    .. [1] Digital Library of Mathematical Functions 29.12
+       https://dlmf.nist.gov/29.12
+    .. [2] Bardhan and Knepley, "Computational science and
+       re-discovery: open-source implementations of
+       ellipsoidal harmonics for problems in potential theory",
+       Comput. Sci. Disc. 5, 014006 (2012)
+       :doi:`10.1088/1749-4699/5/1/014006`.
+    .. [3] David J.and Dechambre P, "Computation of Ellipsoidal
+       Gravity Field Harmonics for small solar system bodies"
+       pp. 30-36, 2000
+    .. [4] George Dassios, "Ellipsoidal Harmonics: Theory and Applications"
+       pp. 418, 2012
+
+    Examples
+    --------
+    >>> from scipy.special import ellip_harm
+    >>> w = ellip_harm(5,8,1,1,2.5)
+    >>> w
+    2.5
+
+    Check that the functions indeed are solutions to the Lamé equation:
+
+    >>> import numpy as np
+    >>> from scipy.interpolate import UnivariateSpline
+    >>> def eigenvalue(f, df, ddf):
+    ...     r = (((s**2 - h**2) * (s**2 - k**2) * ddf
+    ...           + s * (2*s**2 - h**2 - k**2) * df
+    ...           - n * (n + 1)*s**2*f) / f)
+    ...     return -r.mean(), r.std()
+    >>> s = np.linspace(0.1, 10, 200)
+    >>> k, h, n, p = 8.0, 2.2, 3, 2
+    >>> E = ellip_harm(h**2, k**2, n, p, s)
+    >>> E_spl = UnivariateSpline(s, E)
+    >>> a, a_err = eigenvalue(E_spl(s), E_spl(s,1), E_spl(s,2))
+    >>> a, a_err
+    (583.44366156701483, 6.4580890640310646e-11)
+
+    """  # noqa: E501
+    return _ellip_harm(h2, k2, n, p, s, signm, signn)
+
+
+_ellip_harm_2_vec = np.vectorize(_ellipsoid, otypes='d')
+
+
+def ellip_harm_2(h2, k2, n, p, s):
+    r"""
+    Ellipsoidal harmonic functions F^p_n(l).
+
+    These are also known as Lamé functions of the second kind, and are
+    solutions to the Lamé equation:
+
+    .. math:: (s^2 - h^2)(s^2 - k^2)F''(s)
+              + s(2s^2 - h^2 - k^2)F'(s) + (a - q s^2)F(s) = 0
+
+    where :math:`q = (n+1)n` and :math:`a` is the eigenvalue (not
+    returned) corresponding to the solutions.
+
+    Parameters
+    ----------
+    h2 : float
+        ``h**2``
+    k2 : float
+        ``k**2``; should be larger than ``h**2``
+    n : int
+        Degree.
+    p : int
+        Order, can range between [1,2n+1].
+    s : float
+        Coordinate
+
+    Returns
+    -------
+    F : float
+        The harmonic :math:`F^p_n(s)`
+
+    See Also
+    --------
+    ellip_harm, ellip_normal
+
+    Notes
+    -----
+    Lamé functions of the second kind are related to the functions of the first kind:
+
+    .. math::
+
+       F^p_n(s)=(2n + 1)E^p_n(s)\int_{0}^{1/s}
+       \frac{du}{(E^p_n(1/u))^2\sqrt{(1-u^2k^2)(1-u^2h^2)}}
+
+    .. versionadded:: 0.15.0
+
+    Examples
+    --------
+    >>> from scipy.special import ellip_harm_2
+    >>> w = ellip_harm_2(5,8,2,1,10)
+    >>> w
+    0.00108056853382
+
+    """
+    with np.errstate(all='ignore'):
+        return _ellip_harm_2_vec(h2, k2, n, p, s)
+
+
+def _ellip_normal_vec(h2, k2, n, p):
+    return _ellipsoid_norm(h2, k2, n, p)
+
+
+_ellip_normal_vec = np.vectorize(_ellip_normal_vec, otypes='d')
+
+
+def ellip_normal(h2, k2, n, p):
+    r"""
+    Ellipsoidal harmonic normalization constants gamma^p_n.
+
+    The normalization constant is defined as
+
+    .. math::
+
+       \gamma^p_n=8\int_{0}^{h}dx\int_{h}^{k}dy
+       \frac{(y^2-x^2)(E^p_n(y)E^p_n(x))^2}{\sqrt((k^2-y^2)(y^2-h^2)(h^2-x^2)(k^2-x^2)}
+
+    Parameters
+    ----------
+    h2 : float
+        ``h**2``
+    k2 : float
+        ``k**2``; should be larger than ``h**2``
+    n : int
+        Degree.
+    p : int
+        Order, can range between [1,2n+1].
+
+    Returns
+    -------
+    gamma : float
+        The normalization constant :math:`\gamma^p_n`
+
+    See Also
+    --------
+    ellip_harm, ellip_harm_2
+
+    Notes
+    -----
+    .. versionadded:: 0.15.0
+
+    Examples
+    --------
+    >>> from scipy.special import ellip_normal
+    >>> w = ellip_normal(5,8,3,7)
+    >>> w
+    1723.38796997
+
+    """
+    with np.errstate(all='ignore'):
+        return _ellip_normal_vec(h2, k2, n, p)

v12x/pylib/scipy/special/_input_validation.py

@@ -0,0 +1,17 @@
+import math
+import operator
+
+def _nonneg_int_or_fail(n, var_name, strict=True):
+    try:
+        if strict:
+            # Raises an exception if float
+            n = operator.index(n)
+        elif n == math.floor(n):
+            n = int(n)
+        else:
+            raise ValueError()
+        if n < 0:
+            raise ValueError()
+    except (ValueError, TypeError) as err:
+        raise err.__class__(f"{var_name} must be a non-negative integer") from err
+    return n

v12x/pylib/scipy/special/_lambertw.py

@@ -0,0 +1,149 @@
+from ._ufuncs import _lambertw
+
+import numpy as np
+
+
+def lambertw(z, k=0, tol=1e-8):
+    r"""
+    lambertw(z, k=0, tol=1e-8)
+
+    Lambert W function.
+
+    The Lambert W function `W(z)` is defined as the inverse function
+    of ``w * exp(w)``. In other words, the value of ``W(z)`` is
+    such that ``z = W(z) * exp(W(z))`` for any complex number
+    ``z``.
+
+    The Lambert W function is a multivalued function with infinitely
+    many branches. Each branch gives a separate solution of the
+    equation ``z = w exp(w)``. Here, the branches are indexed by the
+    integer `k`.
+
+    Parameters
+    ----------
+    z : array_like
+        Input argument.
+    k : int, optional
+        Branch index.
+    tol : float, optional
+        Evaluation tolerance.
+
+    Returns
+    -------
+    w : array
+        `w` will have the same shape as `z`.
+
+    See Also
+    --------
+    wrightomega : the Wright Omega function
+
+    Notes
+    -----
+    All branches are supported by `lambertw`:
+
+    * ``lambertw(z)`` gives the principal solution (branch 0)
+    * ``lambertw(z, k)`` gives the solution on branch `k`
+
+    The Lambert W function has two partially real branches: the
+    principal branch (`k = 0`) is real for real ``z > -1/e``, and the
+    ``k = -1`` branch is real for ``-1/e < z < 0``. All branches except
+    ``k = 0`` have a logarithmic singularity at ``z = 0``.
+
+    **Possible issues**
+
+    The evaluation can become inaccurate very close to the branch point
+    at ``-1/e``. In some corner cases, `lambertw` might currently
+    fail to converge, or can end up on the wrong branch.
+
+    **Algorithm**
+
+    Halley's iteration is used to invert ``w * exp(w)``, using a first-order
+    asymptotic approximation (O(log(w)) or `O(w)`) as the initial estimate.
+
+    The definition, implementation and choice of branches is based on [2]_.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Lambert_W_function
+    .. [2] Corless et al, "On the Lambert W function", Adv. Comp. Math. 5
+       (1996) 329-359.
+       https://cs.uwaterloo.ca/research/tr/1993/03/W.pdf
+
+    Examples
+    --------
+    The Lambert W function is the inverse of ``w exp(w)``:
+
+    >>> import numpy as np
+    >>> from scipy.special import lambertw
+    >>> w = lambertw(1)
+    >>> w
+    (0.56714329040978384+0j)
+    >>> w * np.exp(w)
+    (1.0+0j)
+
+    Any branch gives a valid inverse:
+
+    >>> w = lambertw(1, k=3)
+    >>> w
+    (-2.8535817554090377+17.113535539412148j)
+    >>> w*np.exp(w)
+    (1.0000000000000002+1.609823385706477e-15j)
+
+    **Applications to equation-solving**
+
+    The Lambert W function may be used to solve various kinds of
+    equations.  We give two examples here.
+
+    First, the function can be used to solve implicit equations of the
+    form
+
+        :math:`x = a + b e^{c x}`
+
+    for :math:`x`.  We assume :math:`c` is not zero.  After a little
+    algebra, the equation may be written
+
+        :math:`z e^z = -b c e^{a c}`
+
+    where :math:`z = c (a - x)`.  :math:`z` may then be expressed using
+    the Lambert W function
+
+        :math:`z = W(-b c e^{a c})`
+
+    giving
+
+        :math:`x = a - W(-b c e^{a c})/c`
+
+    For example,
+
+    >>> a = 3
+    >>> b = 2
+    >>> c = -0.5
+
+    The solution to :math:`x = a + b e^{c x}` is:
+
+    >>> x = a - lambertw(-b*c*np.exp(a*c))/c
+    >>> x
+    (3.3707498368978794+0j)
+
+    Verify that it solves the equation:
+
+    >>> a + b*np.exp(c*x)
+    (3.37074983689788+0j)
+
+    The Lambert W function may also be used find the value of the infinite
+    power tower :math:`z^{z^{z^{\ldots}}}`:
+
+    >>> def tower(z, n):
+    ...     if n == 0:
+    ...         return z
+    ...     return z ** tower(z, n-1)
+    ...
+    >>> tower(0.5, 100)
+    0.641185744504986
+    >>> -lambertw(-np.log(0.5)) / np.log(0.5)
+    (0.64118574450498589+0j)
+    """
+    # TODO: special expert should inspect this
+    # interception; better place to do it?
+    k = np.asarray(k, dtype=np.dtype("long"))
+    return _lambertw(z, k, tol)

v12x/pylib/scipy/special/_logsumexp.py

@@ -0,0 +1,420 @@
+import numpy as np
+from scipy._lib._array_api import (
+    array_namespace,
+    xp_capabilities,
+    xp_device,
+    xp_size,
+    xp_promote,
+    xp_float_to_complex,
+)
+from scipy._external import array_api_extra as xpx
+
+__all__ = ["logsumexp", "softmax", "log_softmax"]
+
+
+@xp_capabilities()
+def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):
+    """Compute the log of the sum of exponentials of input elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes over which the sum is taken. By default `axis` is None,
+        and all elements are summed.
+
+        .. versionadded:: 0.11.0
+    b : array-like, optional
+        Scaling factor for exp(`a`) must be of the same shape as `a` or
+        broadcastable to `a`. These values may be negative in order to
+        implement subtraction.
+
+        .. versionadded:: 0.12.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in the
+        result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original array.
+
+        .. versionadded:: 0.15.0
+    return_sign : bool, optional
+        If this is set to True, the result will be a pair containing sign
+        information; if False, results that are negative will be returned
+        as NaN. Default is False (no sign information).
+
+        .. versionadded:: 0.16.0
+
+    Returns
+    -------
+    res : ndarray
+        The result, ``np.log(np.sum(np.exp(a)))`` calculated in a numerically
+        more stable way. If `b` is given then ``np.log(np.sum(b*np.exp(a)))``
+        is returned. If ``return_sign`` is True, ``res`` contains the log of
+        the absolute value of the argument.
+    sgn : ndarray
+        If ``return_sign`` is True, this will be an array of floating-point
+        numbers matching res containing +1, 0, -1 (for real-valued inputs)
+        or a complex phase (for complex inputs). This gives the sign of the
+        argument of the logarithm in ``res``.
+        If ``return_sign`` is False, only one result is returned.
+
+    See Also
+    --------
+    :data:`numpy.logaddexp`
+    :data:`numpy.logaddexp2`
+
+    Notes
+    -----
+    NumPy has a logaddexp function which is very similar to `logsumexp`, but
+    only handles two arguments. `logaddexp.reduce` is similar to this
+    function, but may be less stable.
+
+    The logarithm is a multivalued function: for each :math:`x` there is an
+    infinite number of :math:`z` such that :math:`exp(z) = x`. The convention
+    is to return the :math:`z` whose imaginary part lies in :math:`(-pi, pi]`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.special import logsumexp
+    >>> a = np.arange(10)
+    >>> logsumexp(a)
+    9.4586297444267107
+    >>> np.log(np.sum(np.exp(a)))
+    9.4586297444267107
+
+    With weights
+
+    >>> a = np.arange(10)
+    >>> b = np.arange(10, 0, -1)
+    >>> logsumexp(a, b=b)
+    9.9170178533034665
+    >>> np.log(np.sum(b*np.exp(a)))
+    9.9170178533034647
+
+    Returning a sign flag
+
+    >>> logsumexp([1,2],b=[1,-1],return_sign=True)
+    (1.5413248546129181, -1.0)
+
+    Notice that `logsumexp` does not directly support masked arrays. To use it
+    on a masked array, convert the mask into zero weights:
+
+    >>> a = np.ma.array([np.log(2), 2, np.log(3)],
+    ...                  mask=[False, True, False])
+    >>> b = (~a.mask).astype(int)
+    >>> logsumexp(a.data, b=b), np.log(5)
+    1.6094379124341005, 1.6094379124341005
+
+    """
+    xp = array_namespace(a, b)
+    a, b = xp_promote(a, b, broadcast=True, force_floating=True, xp=xp)
+    a = xpx.atleast_nd(a, ndim=1, xp=xp)
+    b = xpx.atleast_nd(b, ndim=1, xp=xp) if b is not None else b
+    axis = tuple(range(a.ndim)) if axis is None else axis
+
+    if xp_size(a) != 0:
+        with np.errstate(divide='ignore', invalid='ignore', over='ignore'):
+            # Where result is infinite, we use the direct logsumexp calculation to
+            # delegate edge case handling to the behavior of `xp.log` and `xp.exp`,
+            # which should follow the C99 standard for complex values.
+            b_exp_a = xp.exp(a) if b is None else b * xp.exp(a)
+            sum_ = xp.sum(b_exp_a, axis=axis, keepdims=True)
+            sgn_inf = xp.sign(sum_) if return_sign else None
+            sum_ = xp.abs(sum_) if return_sign else sum_
+            out_inf = xp.log(sum_)
+
+        with np.errstate(divide='ignore', invalid='ignore'):  # log of zero is OK
+            out, sgn = _logsumexp(a, b, axis=axis, return_sign=return_sign, xp=xp)
+
+        # Replace infinite results. This probably could be done with an
+        # `apply_where`-like strategy to avoid redundant calculation, but currently
+        # `apply_where` itself is only for elementwise functions.
+        out_finite = xp.isfinite(out)
+        out = xp.where(out_finite, out, out_inf)
+        sgn = xp.where(out_finite, sgn, sgn_inf) if return_sign else sgn
+    else:
+        shape = np.asarray(a.shape)  # NumPy is convenient for shape manipulation
+        shape[axis] = 1
+        out = xp.full(tuple(shape), -xp.inf, dtype=a.dtype, device=xp_device(a))
+        sgn = xp.sign(out)
+
+    if xp.isdtype(out.dtype, 'complex floating'):
+        if return_sign:
+            real = xp.real(sgn)
+            imag = xp_float_to_complex(_wrap_radians(xp.imag(sgn), xp=xp), xp=xp)
+            sgn = real + imag*1j
+        else:
+            real = xp.real(out)
+            imag = xp_float_to_complex(_wrap_radians(xp.imag(out), xp=xp), xp=xp)
+            out = real + imag*1j
+
+    # Deal with shape details - reducing dimensions and convert 0-D to scalar for NumPy
+    out = xp.squeeze(out, axis=axis) if not keepdims else out
+    sgn = xp.squeeze(sgn, axis=axis) if (sgn is not None and not keepdims) else sgn
+    out = out[()] if out.ndim == 0 else out
+    sgn = sgn[()] if (sgn is not None and sgn.ndim == 0) else sgn
+
+    return (out, sgn) if return_sign else out
+
+
+def _wrap_radians(x, *, xp):
+    # Wrap radians to (-pi, pi] interval
+    wrapped = -((-x + xp.pi) % (2 * xp.pi) - xp.pi)
+    # preserve relative precision
+    no_wrap = xp.abs(x) < xp.pi
+    return xp.where(no_wrap, x, wrapped)
+
+
+def _elements_and_indices_with_max_real(a, *, axis=-1, xp):
+    # This is an array-API compatible `max` function that works something
+    # like `np.max` for complex input. The important part is that it finds
+    # the element with maximum real part. When there are multiple complex values
+    # with this real part, it doesn't matter which we choose.
+    # We could use `argmax` on real component, but array API doesn't yet have
+    # `take_along_axis`, and even if it did, we would have problems with axis tuples.
+    # Feel free to rewrite! It's ugly, but it's not the purpose of the PR, and
+    # it gets the job done.
+
+    if xp.isdtype(a.dtype, "complex floating"):
+        # select all elements with max real part.
+        real_a = xp.real(a)
+        max_ = xp.max(real_a, axis=axis, keepdims=True)
+        mask = real_a == max_
+
+        # Of those, choose one arbitrarily. This is a reasonably
+        # simple, array-API compatible way of doing so that doesn't
+        # have a problem with `axis` being a tuple or None.
+        i = xp.reshape(xp.arange(xp_size(a), device=xp_device(a)), a.shape)
+        i = xpx.at(i, ~mask).set(-1)
+        max_i = xp.max(i, axis=axis, keepdims=True)
+        mask = i == max_i
+        a = xp.where(mask, a, 0.)
+        max_ = xp.sum(a, axis=axis, dtype=a.dtype, keepdims=True)
+    else:
+        max_ = xp.max(a, axis=axis, keepdims=True)
+        mask = a == max_
+
+    return max_, mask
+
+
+def _logsumexp(a, b, *, axis, return_sign, xp):
+    # This has been around for about a decade, so let's consider it a feature:
+    # Even if element of `a` is infinite or NaN, it adds nothing to the sum if
+    # the corresponding weight is zero.
+    if b is not None:
+        a = xpx.at(a, b == 0).set(-xp.inf, copy=True)
+
+    # Find element with maximum real part, since this is what affects the magnitude
+    # of the exponential. Possible enhancement: include log of `b` magnitude in `a`.
+    a_max, i_max = _elements_and_indices_with_max_real(a, axis=axis, xp=xp)
+
+    # for precision, these terms are separated out of the main sum.
+    a = xpx.at(a, i_max).set(-xp.inf, copy=True if b is None else None)
+    i_max_dt = xp.astype(i_max, a.dtype)
+    # This is an inefficient way of getting `m` because it is the sum of a sparse
+    # array; however, this is the simplest way I can think of to get the right shape.
+    b_i_max = i_max_dt if b is None else b * i_max_dt
+    m = xp.sum(b_i_max, axis=axis, keepdims=True, dtype=a.dtype)
+
+    # Shift, exponentiate, scale, and sum
+    exp = b * xp.exp(a - a_max) if b is not None else xp.exp(a - a_max)
+    s = xp.sum(exp, axis=axis, keepdims=True, dtype=exp.dtype)
+    s = xp.where(s == 0, s, s/m)
+
+    # Separate sign/magnitude information
+    # Originally, this was only performed if `return_sign=True`.
+    # However, this is also needed if any elements of `m < 0` or `s < -1`.
+    # An improvement would be to perform the calculations only on these entries.
+
+    sgn = xp.sign(s + 1) * xp.sign(m)
+
+    if xp.isdtype(s.dtype, "real floating"):
+        # The log functions need positive arguments
+        s = xp.where(s < -1, -s - 2, s)
+        m = xp.abs(m)
+    else:
+        # `a_max` can have a sign component for complex input
+        sgn = sgn * xp.exp(xp.imag(a_max) * 1.0j)
+
+    # Take log and undo shift
+    out = xp.log1p(s) + xp.log(m) + a_max
+
+    if return_sign:
+        out = xp.real(out)
+    elif xp.isdtype(out.dtype, 'real floating'):
+        out = xpx.at(out)[sgn < 0].set(xp.nan)
+
+    return out, sgn
+
+
+@xp_capabilities()
+def softmax(x, axis=None):
+    r"""Compute the softmax function.
+
+    The softmax function transforms each element of a collection by
+    computing the exponential of each element divided by the sum of the
+    exponentials of all the elements. That is, if `x` is a one-dimensional
+    numpy array::
+
+        softmax(x) = np.exp(x)/sum(np.exp(x))
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axis : int or tuple of ints, optional
+        Axis to compute values along. Default is None and softmax will be
+        computed over the entire array `x`.
+
+    Returns
+    -------
+    s : ndarray
+        An array the same shape as `x`. The result will sum to 1 along the
+        specified axis.
+
+    Notes
+    -----
+    The formula for the softmax function :math:`\sigma(x)` for a vector
+    :math:`x = \{x_0, x_1, ..., x_{n-1}\}` is
+
+    .. math:: \sigma(x)_j = \frac{e^{x_j}}{\sum_k e^{x_k}}
+
+    The `softmax` function is the gradient of `logsumexp`.
+
+    The implementation uses shifting to avoid overflow. See [1]_ for more
+    details.
+
+    .. versionadded:: 1.2.0
+
+    References
+    ----------
+    .. [1] P. Blanchard, D.J. Higham, N.J. Higham, "Accurately computing the
+       log-sum-exp and softmax functions", IMA Journal of Numerical Analysis,
+       Vol.41(4), :doi:`10.1093/imanum/draa038`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.special import softmax
+    >>> np.set_printoptions(precision=5)
+
+    >>> x = np.array([[1, 0.5, 0.2, 3],
+    ...               [1,  -1,   7, 3],
+    ...               [2,  12,  13, 3]])
+    ...
+
+    Compute the softmax transformation over the entire array.
+
+    >>> m = softmax(x)
+    >>> m
+    array([[  4.48309e-06,   2.71913e-06,   2.01438e-06,   3.31258e-05],
+           [  4.48309e-06,   6.06720e-07,   1.80861e-03,   3.31258e-05],
+           [  1.21863e-05,   2.68421e-01,   7.29644e-01,   3.31258e-05]])
+
+    >>> m.sum()
+    1.0
+
+    Compute the softmax transformation along the first axis (i.e., the
+    columns).
+
+    >>> m = softmax(x, axis=0)
+
+    >>> m
+    array([[  2.11942e-01,   1.01300e-05,   2.75394e-06,   3.33333e-01],
+           [  2.11942e-01,   2.26030e-06,   2.47262e-03,   3.33333e-01],
+           [  5.76117e-01,   9.99988e-01,   9.97525e-01,   3.33333e-01]])
+
+    >>> m.sum(axis=0)
+    array([ 1.,  1.,  1.,  1.])
+
+    Compute the softmax transformation along the second axis (i.e., the rows).
+
+    >>> m = softmax(x, axis=1)
+    >>> m
+    array([[  1.05877e-01,   6.42177e-02,   4.75736e-02,   7.82332e-01],
+           [  2.42746e-03,   3.28521e-04,   9.79307e-01,   1.79366e-02],
+           [  1.22094e-05,   2.68929e-01,   7.31025e-01,   3.31885e-05]])
+
+    >>> m.sum(axis=1)
+    array([ 1.,  1.,  1.])
+
+    """
+    xp = array_namespace(x)
+    x = xp.asarray(x)
+    x_max = xp.max(x, axis=axis, keepdims=True)
+    exp_x_shifted = xp.exp(x - x_max)
+    return exp_x_shifted / xp.sum(exp_x_shifted, axis=axis, keepdims=True)
+
+
+@xp_capabilities()
+def log_softmax(x, axis=None):
+    r"""Compute the logarithm of the softmax function.
+
+    In principle::
+
+        log_softmax(x) = log(softmax(x))
+
+    but using a more accurate implementation.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axis : int or tuple of ints, optional
+        Axis to compute values along. Default is None and softmax will be
+        computed over the entire array `x`.
+
+    Returns
+    -------
+    s : ndarray or scalar
+        An array with the same shape as `x`. Exponential of the result will
+        sum to 1 along the specified axis. If `x` is a scalar, a scalar is
+        returned.
+
+    Notes
+    -----
+    `log_softmax` is more accurate than ``np.log(softmax(x))`` with inputs that
+    make `softmax` saturate (see examples below).
+
+    .. versionadded:: 1.5.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.special import log_softmax
+    >>> from scipy.special import softmax
+    >>> np.set_printoptions(precision=5)
+
+    >>> x = np.array([1000.0, 1.0])
+
+    >>> y = log_softmax(x)
+    >>> y
+    array([   0., -999.])
+
+    >>> with np.errstate(divide='ignore'):
+    ...   y = np.log(softmax(x))
+    ...
+    >>> y
+    array([  0., -inf])
+
+    """
+    xp = array_namespace(x)
+    x = xp.asarray(x)
+
+    x_max = xp.max(x, axis=axis, keepdims=True)
+
+    if x_max.ndim > 0:
+        x_max = xpx.at(x_max, ~xp.isfinite(x_max)).set(0)
+    elif not xp.isfinite(x_max):
+        x_max = 0
+
+    tmp = x - x_max
+    exp_tmp = xp.exp(tmp)
+
+    # suppress warnings about log of zero
+    with np.errstate(divide='ignore'):
+        s = xp.sum(exp_tmp, axis=axis, keepdims=True)
+        out = xp.log(s)
+
+    return tmp - out

v12x/pylib/scipy/special/_mptestutils.py

@@ -0,0 +1,453 @@
+import os
+import sys
+import time
+from itertools import zip_longest
+
+import numpy as np
+from numpy.testing import assert_
+import pytest
+
+from scipy.special._testutils import assert_func_equal
+
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+# ------------------------------------------------------------------------------
+# Machinery for systematic tests with mpmath
+# ------------------------------------------------------------------------------
+
+class Arg:
+    """Generate a set of numbers on the real axis, concentrating on
+    'interesting' regions and covering all orders of magnitude.
+
+    """
+
+    def __init__(self, a=-np.inf, b=np.inf, inclusive_a=True, inclusive_b=True):
+        if a > b:
+            raise ValueError("a should be less than or equal to b")
+        if a == -np.inf:
+            a = -0.5*np.finfo(float).max
+        if b == np.inf:
+            b = 0.5*np.finfo(float).max
+        self.a, self.b = a, b
+
+        self.inclusive_a, self.inclusive_b = inclusive_a, inclusive_b
+
+    def _positive_values(self, a, b, n):
+        if a < 0:
+            raise ValueError("a should be positive")
+
+        # Try to put half of the points into a linspace between a and
+        # 10 the other half in a logspace.
+        if n % 2 == 0:
+            nlogpts = n//2
+            nlinpts = nlogpts
+        else:
+            nlogpts = n//2
+            nlinpts = nlogpts + 1
+
+        if a >= 10:
+            # Outside of linspace range; just return a logspace.
+            pts = np.logspace(np.log10(a), np.log10(b), n)
+        elif a > 0 and b < 10:
+            # Outside of logspace range; just return a linspace
+            pts = np.linspace(a, b, n)
+        elif a > 0:
+            # Linspace between a and 10 and a logspace between 10 and
+            # b.
+            linpts = np.linspace(a, 10, nlinpts, endpoint=False)
+            logpts = np.logspace(1, np.log10(b), nlogpts)
+            pts = np.hstack((linpts, logpts))
+        elif a == 0 and b <= 10:
+            # Linspace between 0 and b and a logspace between 0 and
+            # the smallest positive point of the linspace
+            linpts = np.linspace(0, b, nlinpts)
+            if linpts.size > 1:
+                right = np.log10(linpts[1])
+            else:
+                right = -30
+            logpts = np.logspace(-30, right, nlogpts, endpoint=False)
+            pts = np.hstack((logpts, linpts))
+        else:
+            # Linspace between 0 and 10, logspace between 0 and the
+            # smallest positive point of the linspace, and a logspace
+            # between 10 and b.
+            if nlogpts % 2 == 0:
+                nlogpts1 = nlogpts//2
+                nlogpts2 = nlogpts1
+            else:
+                nlogpts1 = nlogpts//2
+                nlogpts2 = nlogpts1 + 1
+            linpts = np.linspace(0, 10, nlinpts, endpoint=False)
+            if linpts.size > 1:
+                right = np.log10(linpts[1])
+            else:
+                right = -30
+            logpts1 = np.logspace(-30, right, nlogpts1, endpoint=False)
+            logpts2 = np.logspace(1, np.log10(b), nlogpts2)
+            pts = np.hstack((logpts1, linpts, logpts2))
+
+        return np.sort(pts)
+
+    def values(self, n):
+        """Return an array containing n numbers."""
+        a, b = self.a, self.b
+        if a == b:
+            return np.zeros(n)
+
+        if not self.inclusive_a:
+            n += 1
+        if not self.inclusive_b:
+            n += 1
+
+        if n % 2 == 0:
+            n1 = n//2
+            n2 = n1
+        else:
+            n1 = n//2
+            n2 = n1 + 1
+
+        if a >= 0:
+            pospts = self._positive_values(a, b, n)
+            negpts = []
+        elif b <= 0:
+            pospts = []
+            negpts = -self._positive_values(-b, -a, n)
+        else:
+            pospts = self._positive_values(0, b, n1)
+            negpts = -self._positive_values(0, -a, n2 + 1)
+            # Don't want to get zero twice
+            negpts = negpts[1:]
+        pts = np.hstack((negpts[::-1], pospts))
+
+        if not self.inclusive_a:
+            pts = pts[1:]
+        if not self.inclusive_b:
+            pts = pts[:-1]
+        return pts
+
+
+class FixedArg:
+    def __init__(self, values):
+        self._values = np.asarray(values)
+
+    def values(self, n):
+        return self._values
+
+
+class ComplexArg:
+    def __init__(self, a=complex(-np.inf, -np.inf), b=complex(np.inf, np.inf)):
+        self.real = Arg(a.real, b.real)
+        self.imag = Arg(a.imag, b.imag)
+
+    def values(self, n):
+        m = int(np.floor(np.sqrt(n)))
+        x = self.real.values(m)
+        y = self.imag.values(m + 1)
+        return (x[:,None] + 1j*y[None,:]).ravel()
+
+
+class IntArg:
+    def __init__(self, a=-1000, b=1000):
+        self.a = a
+        self.b = b
+
+    def values(self, n):
+        v1 = Arg(self.a, self.b).values(max(1 + n//2, n-5)).astype(int)
+        v2 = np.arange(-5, 5)
+        v = np.unique(np.r_[v1, v2])
+        v = v[(v >= self.a) & (v < self.b)]
+        return v
+
+
+def get_args(argspec, n):
+    if isinstance(argspec, np.ndarray):
+        args = argspec.copy()
+    else:
+        nargs = len(argspec)
+        ms = np.asarray(
+            [1.5 if isinstance(spec, ComplexArg) else 1.0 for spec in argspec]
+        )
+        ms = (n**(ms/sum(ms))).astype(int) + 1
+
+        args = [spec.values(m) for spec, m in zip(argspec, ms)]
+        args = np.array(np.broadcast_arrays(*np.ix_(*args))).reshape(nargs, -1).T
+
+    return args
+
+
+class MpmathData:
+    def __init__(self, scipy_func, mpmath_func, arg_spec, name=None,
+                 dps=None, prec=None, n=None, rtol=1e-7, atol=1e-300,
+                 ignore_inf_sign=False, distinguish_nan_and_inf=True,
+                 nan_ok=True, param_filter=None):
+
+        # mpmath tests are really slow (see gh-6989).  Use a small number of
+        # points by default, increase back to 5000 (old default) if XSLOW is
+        # set
+        if n is None:
+            try:
+                is_xslow = int(os.environ.get('SCIPY_XSLOW', '0'))
+            except ValueError:
+                is_xslow = False
+
+            n = 5000 if is_xslow else 500
+
+        self.scipy_func = scipy_func
+        self.mpmath_func = mpmath_func
+        self.arg_spec = arg_spec
+        self.dps = dps
+        self.prec = prec
+        self.n = n
+        self.rtol = rtol
+        self.atol = atol
+        self.ignore_inf_sign = ignore_inf_sign
+        self.nan_ok = nan_ok
+        if isinstance(self.arg_spec, np.ndarray):
+            self.is_complex = np.issubdtype(self.arg_spec.dtype, np.complexfloating)
+        else:
+            self.is_complex = any(
+                [isinstance(arg, ComplexArg) for arg in self.arg_spec]
+            )
+        self.ignore_inf_sign = ignore_inf_sign
+        self.distinguish_nan_and_inf = distinguish_nan_and_inf
+        if not name or name == '<lambda>':
+            name = getattr(scipy_func, '__name__', None)
+        if not name or name == '<lambda>':
+            name = getattr(mpmath_func, '__name__', None)
+        self.name = name
+        self.param_filter = param_filter
+
+    def check(self):
+        np.random.seed(1234)
+
+        # Generate values for the arguments
+        argarr = get_args(self.arg_spec, self.n)
+
+        # Check
+        old_dps, old_prec = mpmath.mp.dps, mpmath.mp.prec
+        try:
+            if self.dps is not None:
+                dps_list = [self.dps]
+            else:
+                dps_list = [20]
+            if self.prec is not None:
+                mpmath.mp.prec = self.prec
+
+            # Proper casting of mpmath input and output types. Using
+            # native mpmath types as inputs gives improved precision
+            # in some cases.
+            if np.issubdtype(argarr.dtype, np.complexfloating):
+                pytype = mpc2complex
+
+                def mptype(x):
+                    return mpmath.mpc(complex(x))
+            else:
+                def mptype(x):
+                    return mpmath.mpf(float(x))
+
+                def pytype(x):
+                    if abs(x.imag) > 1e-16*(1 + abs(x.real)):
+                        return np.nan
+                    else:
+                        return mpf2float(x.real)
+
+            # Try out different dps until one (or none) works
+            for j, dps in enumerate(dps_list):
+                mpmath.mp.dps = dps
+
+                try:
+                    assert_func_equal(
+                        self.scipy_func,
+                        lambda *a: pytype(self.mpmath_func(*map(mptype, a))),
+                        argarr,
+                        vectorized=False,
+                        rtol=self.rtol,
+                        atol=self.atol,
+                        ignore_inf_sign=self.ignore_inf_sign,
+                        distinguish_nan_and_inf=self.distinguish_nan_and_inf,
+                        nan_ok=self.nan_ok,
+                        param_filter=self.param_filter
+                    )
+                    break
+                except AssertionError:
+                    if j >= len(dps_list)-1:
+                        # reraise the Exception
+                        tp, value, tb = sys.exc_info()
+                        if value.__traceback__ is not tb:
+                            raise value.with_traceback(tb)
+                        raise value
+        finally:
+            mpmath.mp.dps, mpmath.mp.prec = old_dps, old_prec
+
+    def __repr__(self):
+        if self.is_complex:
+            return f"<MpmathData: {self.name} (complex)>"
+        else:
+            return f"<MpmathData: {self.name}>"
+
+
+def assert_mpmath_equal(*a, **kw):
+    d = MpmathData(*a, **kw)
+    d.check()
+
+
+def nonfunctional_tooslow(func):
+    return pytest.mark.skip(
+        reason="    Test not yet functional (too slow), needs more work."
+    )(func)
+
+
+# ------------------------------------------------------------------------------
+# Tools for dealing with mpmath quirks
+# ------------------------------------------------------------------------------
+
+def mpf2float(x):
+    """
+    Convert an mpf to the nearest floating point number. Just using
+    float directly doesn't work because of results like this:
+
+    with mp.workdps(50):
+        float(mpf("0.99999999999999999")) = 0.9999999999999999
+
+    """
+    return float(mpmath.nstr(x, 17, min_fixed=0, max_fixed=0))
+
+
+def mpc2complex(x):
+    return complex(mpf2float(x.real), mpf2float(x.imag))
+
+
+def trace_args(func):
+    def tofloat(x):
+        if isinstance(x, mpmath.mpc):
+            return complex(x)
+        else:
+            return float(x)
+
+    def wrap(*a, **kw):
+        sys.stderr.write(f"{tuple(map(tofloat, a))!r}: ")
+        sys.stderr.flush()
+        try:
+            r = func(*a, **kw)
+            sys.stderr.write(f"-> {r!r}")
+        finally:
+            sys.stderr.write("\n")
+            sys.stderr.flush()
+        return r
+    return wrap
+
+
+try:
+    import signal
+    POSIX = ('setitimer' in dir(signal))
+except ImportError:
+    POSIX = False
+
+
+class TimeoutError(Exception):
+    pass
+
+
+def time_limited(timeout=0.5, return_val=np.nan, use_sigalrm=True):
+    """
+    Decorator for setting a timeout for pure-Python functions.
+
+    If the function does not return within `timeout` seconds, the
+    value `return_val` is returned instead.
+
+    On POSIX this uses SIGALRM by default. On non-POSIX, settrace is
+    used. Do not use this with threads: the SIGALRM implementation
+    does probably not work well. The settrace implementation only
+    traces the current thread.
+
+    The settrace implementation slows down execution speed. Slowdown
+    by a factor around 10 is probably typical.
+    """
+    if POSIX and use_sigalrm:
+        def sigalrm_handler(signum, frame):
+            raise TimeoutError()
+
+        def deco(func):
+            def wrap(*a, **kw):
+                old_handler = signal.signal(signal.SIGALRM, sigalrm_handler)
+                signal.setitimer(signal.ITIMER_REAL, timeout)
+                try:
+                    return func(*a, **kw)
+                except TimeoutError:
+                    return return_val
+                finally:
+                    signal.setitimer(signal.ITIMER_REAL, 0)
+                    signal.signal(signal.SIGALRM, old_handler)
+            return wrap
+    else:
+        def deco(func):
+            def wrap(*a, **kw):
+                start_time = time.time()
+
+                def trace(frame, event, arg):
+                    if time.time() - start_time > timeout:
+                        raise TimeoutError()
+                    return trace
+                sys.settrace(trace)
+                try:
+                    return func(*a, **kw)
+                except TimeoutError:
+                    sys.settrace(None)
+                    return return_val
+                finally:
+                    sys.settrace(None)
+            return wrap
+    return deco
+
+
+def exception_to_nan(func):
+    """Decorate function to return nan if it raises an exception"""
+    def wrap(*a, **kw):
+        try:
+            return func(*a, **kw)
+        except Exception:
+            return np.nan
+    return wrap
+
+
+def inf_to_nan(func):
+    """Decorate function to return nan if it returns inf"""
+    def wrap(*a, **kw):
+        v = func(*a, **kw)
+        if not np.isfinite(v):
+            return np.nan
+        return v
+    return wrap
+
+
+def mp_assert_allclose(res, std, atol=0, rtol=1e-17):
+    """
+    Compare lists of mpmath.mpf's or mpmath.mpc's directly so that it
+    can be done to higher precision than double.
+    """
+    failures = []
+    for k, (resval, stdval) in enumerate(zip_longest(res, std)):
+        if resval is None or stdval is None:
+            raise ValueError('Lengths of inputs res and std are not equal.')
+        if mpmath.fabs(resval - stdval) > atol + rtol*mpmath.fabs(stdval):
+            failures.append((k, resval, stdval))
+
+    nfail = len(failures)
+    if nfail > 0:
+        ndigits = int(abs(np.log10(rtol)))
+        msg = [""]
+        msg.append(f"Bad results ({nfail} out of {k + 1}) for the following points:")
+        for k, resval, stdval in failures:
+            resrep = mpmath.nstr(resval, ndigits, min_fixed=0, max_fixed=0)
+            stdrep = mpmath.nstr(stdval, ndigits, min_fixed=0, max_fixed=0)
+            if stdval == 0:
+                rdiff = "inf"
+            else:
+                rdiff = mpmath.fabs((resval - stdval)/stdval)
+                rdiff = mpmath.nstr(rdiff, 3)
+            msg.append(f"{k}: {resrep} != {stdrep} (rdiff {rdiff})")
+        assert_(False, "\n".join(msg))

v12x/pylib/scipy/special/_multiufuncs.py

@@ -0,0 +1,744 @@
+import collections
+import numbers
+import numpy as np
+
+from ._input_validation import _nonneg_int_or_fail
+
+from ._special_ufuncs import (legendre_p, assoc_legendre_p,
+                              sph_legendre_p, sph_harm_y)
+from ._gufuncs import (legendre_p_all, assoc_legendre_p_all,
+                       sph_legendre_p_all, sph_harm_y_all)
+
+__all__ = [
+    "assoc_legendre_p",
+    "assoc_legendre_p_all",
+    "legendre_p",
+    "legendre_p_all",
+    "sph_harm_y",
+    "sph_harm_y_all",
+    "sph_legendre_p",
+    "sph_legendre_p_all",
+]
+
+
+class MultiUFunc:
+    def __init__(self, ufunc_or_ufuncs, name=None, doc=None, *,
+                 force_complex_output=False, **default_kwargs):
+        if not isinstance(ufunc_or_ufuncs, np.ufunc):
+            if isinstance(ufunc_or_ufuncs, collections.abc.Mapping):
+                ufuncs_iter = ufunc_or_ufuncs.values()
+            elif isinstance(ufunc_or_ufuncs, collections.abc.Iterable):
+                ufuncs_iter = ufunc_or_ufuncs
+            else:
+                raise ValueError("ufunc_or_ufuncs should be a ufunc or a"
+                                 " ufunc collection")
+
+            # Perform input validation to ensure all ufuncs in ufuncs are
+            # actually ufuncs and all take the same input types.
+            seen_input_types = set()
+            for ufunc in ufuncs_iter:
+                if not isinstance(ufunc, np.ufunc):
+                    raise ValueError("All ufuncs must have type `numpy.ufunc`."
+                                     f" Received {ufunc_or_ufuncs}")
+                seen_input_types.add(frozenset(x.split("->")[0] for x in ufunc.types))
+            if len(seen_input_types) > 1:
+                raise ValueError("All ufuncs must take the same input types.")
+
+        self.__name__ = name
+        self._ufunc_or_ufuncs = ufunc_or_ufuncs
+        self.__doc = doc
+        self.__force_complex_output = force_complex_output
+        self._default_kwargs = default_kwargs
+        self._resolve_out_shapes = None
+        self._finalize_out = None
+        self._key = None
+        self._ufunc_default_args = lambda *args, **kwargs: ()
+        self._ufunc_default_kwargs = lambda *args, **kwargs: {}
+        self.__text_signature__ = doc.split("\n\n")[0] if doc else None
+
+    @property
+    def __doc__(self):  # pyrefly:ignore[bad-override]
+        return self.__doc
+
+    def _override_key(self, func):
+        """Set `key` method by decorating a function.
+        """
+        self._key = func
+
+    def _override_ufunc_default_args(self, func):
+        self._ufunc_default_args = func
+
+    def _override_ufunc_default_kwargs(self, func):
+        self._ufunc_default_kwargs = func
+
+    def _override_resolve_out_shapes(self, func):
+        """Set `resolve_out_shapes` method by decorating a function."""
+        if func.__doc__ is None:
+            func.__doc__ = \
+                """Resolve to output shapes based on relevant inputs."""
+        func.__name__ = "resolve_out_shapes"
+        self._resolve_out_shapes = func
+
+    def _override_finalize_out(self, func):
+        self._finalize_out = func
+
+    def _resolve_ufunc(self, **kwargs):
+        """Resolve to a ufunc based on keyword arguments."""
+
+        if isinstance(self._ufunc_or_ufuncs, np.ufunc):
+            return self._ufunc_or_ufuncs
+
+        ufunc_key = self._key(**kwargs)
+        return self._ufunc_or_ufuncs[ufunc_key]
+
+    def __call__(self, *args, **kwargs):
+        kwargs = self._default_kwargs | kwargs
+
+        args += self._ufunc_default_args(**kwargs)
+
+        ufunc = self._resolve_ufunc(**kwargs)
+
+        # array arguments to be passed to the ufunc
+        ufunc_args = [np.asarray(arg) for arg in args[-ufunc.nin:]]
+
+        ufunc_kwargs = self._ufunc_default_kwargs(**kwargs)
+
+        if (self._resolve_out_shapes is not None):
+            ufunc_arg_shapes = tuple(np.shape(ufunc_arg) for ufunc_arg in ufunc_args)
+            ufunc_out_shapes = self._resolve_out_shapes(*args[:-ufunc.nin],
+                                                        *ufunc_arg_shapes, ufunc.nout,
+                                                        **kwargs)
+
+            ufunc_arg_dtypes = tuple(ufunc_arg.dtype if hasattr(ufunc_arg, 'dtype')
+                                     else np.dtype(type(ufunc_arg))
+                                     for ufunc_arg in ufunc_args)
+
+            if hasattr(ufunc, 'resolve_dtypes'):
+                ufunc_dtypes = ufunc_arg_dtypes + ufunc.nout * (None,)
+                ufunc_dtypes = ufunc.resolve_dtypes(ufunc_dtypes)
+                ufunc_out_dtypes = ufunc_dtypes[-ufunc.nout:]
+            else:
+                ufunc_out_dtype = np.result_type(*ufunc_arg_dtypes)
+                if (not np.issubdtype(ufunc_out_dtype, np.inexact)):
+                    ufunc_out_dtype = np.float64
+
+                ufunc_out_dtypes = ufunc.nout * (ufunc_out_dtype,)
+
+            if self.__force_complex_output:
+                ufunc_out_dtypes = tuple(np.result_type(1j, ufunc_out_dtype)
+                                         for ufunc_out_dtype in ufunc_out_dtypes)
+
+            out = tuple(np.empty(ufunc_out_shape, dtype=ufunc_out_dtype)
+                        for ufunc_out_shape, ufunc_out_dtype
+                        in zip(ufunc_out_shapes, ufunc_out_dtypes))
+
+            ufunc_kwargs['out'] = out
+
+        out = ufunc(*ufunc_args, **ufunc_kwargs)
+        if (self._finalize_out is not None):
+            out = self._finalize_out(out)
+
+        return out
+
+
+sph_legendre_p = MultiUFunc(
+    sph_legendre_p,
+    "sph_legendre_p",
+    r"""sph_legendre_p(n, m, theta, *, diff_n=0)
+
+    Spherical Legendre polynomial of the first kind.
+
+    Parameters
+    ----------
+    n : array_like of ints
+        Degree of the spherical Legendre polynomial. Must have ``n >= 0``.
+    m : array_like of ints
+        Order of the spherical Legendre polynomial.
+    theta : array_like
+        Input value.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order `diff_n`. Default is 0.
+
+    Returns
+    -------
+    ndarray or tuple of ndarray
+        Spherical Legendre polynomial with ``diff_n`` derivatives.
+
+    Notes
+    -----
+    The spherical counterpart of an (unnormalized) associated Legendre polynomial has
+    the additional factor
+
+    .. math::
+
+        \sqrt{\frac{(2 n + 1) (n - m)!}{4 \pi (n + m)!}}
+
+    It is the same as the spherical harmonic :math:`Y_{n}^{m}(\theta, \phi)`
+    with :math:`\phi = 0`.
+    """, diff_n=0
+)
+
+
+@sph_legendre_p._override_key
+def _(diff_n):
+    diff_n = _nonneg_int_or_fail(diff_n, "diff_n", strict=False)
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return diff_n
+
+
+@sph_legendre_p._override_finalize_out
+def _(out):
+    return np.moveaxis(out, -1, 0)
+
+
+sph_legendre_p_all = MultiUFunc(
+    sph_legendre_p_all,
+    "sph_legendre_p_all",
+    """sph_legendre_p_all(n, m, theta, *, diff_n=0)
+
+    All spherical Legendre polynomials of the first kind up to the
+    specified degree `n`, order `m`, and all derivatives up
+    to order `diff_n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the spherical Legendre polynomials. Must have ``n >= 0``.
+    m : int
+        Order of the spherical Legendre polynomials.
+    theta : array_like
+        Input value.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order `diff_n`. Default is 0.
+
+    Returns
+    -------
+    ndarray
+        Output shape is ``(diff_n + 1, n + 1, 2 * m + 1, ...)``. The entry at
+        ``(i, j, k)`` corresponds to the ``i``-th derivative, degree ``j``, and
+        order ``k`` for all ``0 <= i <= diff_n``, ``0 <= j <= n``, and
+        ``-m <= k <= m``.
+
+    See Also
+    --------
+    sph_legendre_p
+    """, diff_n=0
+)
+
+
+@sph_legendre_p_all._override_key
+def _(diff_n):
+    diff_n = _nonneg_int_or_fail(diff_n, "diff_n", strict=False)
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return diff_n
+
+
+@sph_legendre_p_all._override_ufunc_default_kwargs
+def _(diff_n):
+    return {'axes': [()] + [(0, 1, -1)]}
+
+
+@sph_legendre_p_all._override_resolve_out_shapes
+def _(n, m, theta_shape, nout, diff_n):
+    if not isinstance(n, numbers.Integral) or (n < 0):
+        raise ValueError("n must be a non-negative integer.")
+
+    return ((n + 1, 2 * abs(m) + 1) + theta_shape + (diff_n + 1,),)
+
+
+@sph_legendre_p_all._override_finalize_out
+def _(out):
+    return np.moveaxis(out, -1, 0)
+
+
+assoc_legendre_p = MultiUFunc(
+    assoc_legendre_p,
+    "assoc_legendre_p",
+    r"""assoc_legendre_p(n, m, z, *, branch_cut=2, norm=False, diff_n=0)
+
+    Associated Legendre polynomial of the first kind.
+
+    Defined as
+
+    .. math::
+
+        P_n^m(z) = (-1)^m (1 - z^2)^{m/2}
+            \frac{d^m}{dz^m} P_n(z)
+
+    where :math:`P_n` is the Legendre polynomial.
+
+    This definition includes the Condon-Shortley phase :math:`(-1)^m`.
+
+    Parameters
+    ----------
+    n : array_like of ints
+        Degree of the associated Legendre polynomial. Must have ``n >= 0``.
+    m : array_like of ints
+        Order of the associated Legendre polynomial.
+    z : array_like
+        Input value.
+    branch_cut : array_like of ints, optional
+        Selects branch cut. Must be 2 (default) or 3.
+        2: cut on the real axis ``|z| > 1``
+        3: cut on the real axis ``-1 < z < 1``
+    norm : bool, optional
+        If ``True``, compute the normalized associated Legendre polynomial.
+        Default is ``False``.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order ``diff_n``. Default is 0.
+
+    Returns
+    -------
+    ndarray or tuple of ndarray
+        Associated Legendre polynomial with ``diff_n`` derivatives.
+
+    Notes
+    -----
+    The normalized counterpart of an (unnormalized) associated Legendre
+    polynomial has the additional factor
+
+    .. math::
+
+        \sqrt{\frac{(2 n + 1) (n - m)!}{2 (n + m)!}}
+
+    Examples
+    --------
+    Evaluate :math:`P_2^1(z)` on :math:`[-1, 1]`:
+
+    >>> import numpy as np
+    >>> from scipy.special import assoc_legendre_p
+    >>> z = np.linspace(-1, 1, 11)
+    >>> expected = -3 * z * np.sqrt(1 - z**2)
+    >>> np.allclose(assoc_legendre_p(2, 1, z), expected)
+    True
+
+    Compute the normalized associated Legendre polynomial:
+
+    >>> scale = np.sqrt(5/12)
+    >>> np.allclose(assoc_legendre_p(2, 1, z, norm=True), scale * expected)
+    True
+    """, branch_cut=2, norm=False, diff_n=0
+)
+
+
+@assoc_legendre_p._override_key
+def _(branch_cut, norm, diff_n):
+    diff_n = _nonneg_int_or_fail(diff_n, "diff_n", strict=False)
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return norm, diff_n
+
+
+@assoc_legendre_p._override_ufunc_default_args
+def _(branch_cut, norm, diff_n):
+    return branch_cut,
+
+
+@assoc_legendre_p._override_finalize_out
+def _(out):
+    return np.moveaxis(out, -1, 0)
+
+
+assoc_legendre_p_all = MultiUFunc(
+    assoc_legendre_p_all,
+    "assoc_legendre_p_all",
+    """assoc_legendre_p_all(n, m, z, *, branch_cut=2, norm=False, diff_n=0)
+
+    All associated Legendre polynomials of the first kind up to the
+    specified degree `n`, order `m`, and all derivatives up
+    to order `diff_n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the associated Legendre polynomials. Must have ``n >= 0``.
+    m : int
+        Order of the associated Legendre polynomials.
+    z : array_like
+        Input value.
+    branch_cut : array_like of ints, optional
+        Selects branch cut. Must be 2 (default) or 3.
+        2: cut on the real axis ``|z| > 1``
+        3: cut on the real axis ``-1 < z < 1``
+    norm : bool, optional
+        If ``True``, compute the normalized associated Legendre polynomials.
+        Default is ``False``.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order ``diff_n``. Default is 0.
+
+    Returns
+    -------
+    ndarray
+        Output shape is ``(diff_n + 1, n + 1, 2 * m + 1, ...)``. The entry at
+        ``(i, j, k)`` corresponds to the ``i``-th derivative, degree ``j``, and
+        order ``k`` for all ``0 <= i <= diff_n``, ``0 <= j <= n``, and
+        ``-m <= k <= m``.
+
+    See Also
+    --------
+    assoc_legendre_p
+    """, branch_cut=2, norm=False, diff_n=0
+)
+
+
+@assoc_legendre_p_all._override_key
+def _(branch_cut, norm, diff_n):
+    if not ((isinstance(diff_n, numbers.Integral))
+            and diff_n >= 0):
+        raise ValueError(
+            f"diff_n must be a non-negative integer, received: {diff_n}."
+        )
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return norm, diff_n
+
+
+@assoc_legendre_p_all._override_ufunc_default_args
+def _(branch_cut, norm, diff_n):
+    return branch_cut,
+
+
+@assoc_legendre_p_all._override_ufunc_default_kwargs
+def _(branch_cut, norm, diff_n):
+    return {'axes': [(), ()] + [(0, 1, -1)]}
+
+
+@assoc_legendre_p_all._override_resolve_out_shapes
+def _(n, m, z_shape, branch_cut_shape, nout, **kwargs):
+    diff_n = kwargs['diff_n']
+
+    if not isinstance(n, numbers.Integral) or (n < 0):
+        raise ValueError("n must be a non-negative integer.")
+    if not isinstance(m, numbers.Integral) or (m < 0):
+        raise ValueError("m must be a non-negative integer.")
+
+    return ((n + 1, 2 * abs(m) + 1) +
+        np.broadcast_shapes(z_shape, branch_cut_shape) + (diff_n + 1,),)
+
+
+@assoc_legendre_p_all._override_finalize_out
+def _(out):
+    return np.moveaxis(out, -1, 0)
+
+
+legendre_p = MultiUFunc(
+    legendre_p,
+    "legendre_p",
+    """legendre_p(n, z, *, diff_n=0)
+
+    Legendre polynomial of the first kind.
+
+    Parameters
+    ----------
+    n : array_like of ints
+        Degree of the Legendre polynomial. Must have ``n >= 0``.
+    z : array_like
+        Input value.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order ``diff_n``. Default is 0.
+
+    Returns
+    -------
+    p : ndarray or tuple of ndarray
+        Legendre polynomial with ``diff_n`` derivatives.
+
+    See Also
+    --------
+    legendre
+
+    References
+    ----------
+    .. [1] Zhang, Shanjie and Jin, Jianming. "Computation of Special
+           Functions", John Wiley and Sons, 1996.
+           https://people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
+
+    Examples
+    --------
+    Evaluate the Legendre polynomial :math:`P_3` at :math:`z = 0.5`:
+
+    >>> import numpy as np
+    >>> from scipy.special import legendre_p
+    >>> np.allclose(legendre_p(3, 0.5), -0.4375)
+    True
+
+    Compute the value and first derivative with respect to ``z``:
+
+    >>> p, dp = legendre_p(3, 0.5, diff_n=1)
+    >>> np.allclose([p, dp], [-0.4375, 0.375])
+    True
+    """, diff_n=0
+)
+
+
+@legendre_p._override_key
+def _(diff_n):
+    if (not isinstance(diff_n, numbers.Integral)) or (diff_n < 0):
+        raise ValueError(
+            f"diff_n must be a non-negative integer, received: {diff_n}."
+        )
+    if not 0 <= diff_n <= 2:
+        raise NotImplementedError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return diff_n
+
+
+@legendre_p._override_finalize_out
+def _(out):
+    return np.moveaxis(out, -1, 0)
+
+
+legendre_p_all = MultiUFunc(
+    legendre_p_all,
+    "legendre_p_all",
+    """legendre_p_all(n, z, *, diff_n=0)
+
+    All Legendre polynomials of the first kind up to the specified degree
+    `n` and all derivatives up to order `diff_n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the Legendre polynomials. Must have ``n >= 0``.
+    z : array_like
+        Input value.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order ``diff_n``. Default is 0.
+
+    Returns
+    -------
+    ndarray
+        Output shape is ``(diff_n + 1, n + 1, ...)``. The entry at ``(i, j)``
+        corresponds to the ``i``-th derivative and degree ``j`` for all
+        ``0 <= i <= diff_n`` and ``0 <= j <= n``.
+
+    See Also
+    --------
+    legendre_p
+    """, diff_n=0
+)
+
+
+@legendre_p_all._override_key
+def _(diff_n):
+    diff_n = _nonneg_int_or_fail(diff_n, "diff_n", strict=False)
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return diff_n
+
+
+@legendre_p_all._override_ufunc_default_kwargs
+def _(diff_n):
+    return {'axes': [(), (0, -1)]}
+
+
+@legendre_p_all._override_resolve_out_shapes
+def _(n, z_shape, nout, diff_n):
+    n = _nonneg_int_or_fail(n, 'n', strict=False)
+
+    return nout * ((n + 1,) + z_shape + (diff_n + 1,),)
+
+
+@legendre_p_all._override_finalize_out
+def _(out):
+    return np.moveaxis(out, -1, 0)
+
+
+sph_harm_y = MultiUFunc(
+    sph_harm_y,
+    "sph_harm_y",
+    r"""sph_harm_y(n, m, theta, phi, *, diff_n=0)
+
+    Spherical harmonics.
+
+    They are defined as
+
+    .. math::
+
+        Y_n^m(\theta,\phi) = \sqrt{\frac{2 n + 1}{4 \pi} \frac{(n - m)!}{(n + m)!}}
+            P_n^m(\cos(\theta)) e^{i m \phi}
+
+    where :math:`P_n^m` are the (unnormalized) associated Legendre polynomials.
+
+    Parameters
+    ----------
+    n : array_like of ints
+        Degree of the harmonic. Must have ``n >= 0``. This is
+        often denoted by ``l`` (lower case L) in descriptions of
+        spherical harmonics.
+    m : array_like of ints
+        Order of the harmonic.
+    theta : array_like
+        Polar (colatitudinal) coordinate; must be in ``[0, pi]``.
+    phi : array_like
+        Azimuthal (longitudinal) coordinate; must be in ``[0, 2*pi]``.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order `diff_n`. Default is 0.
+
+    Returns
+    -------
+    ndarray or tuple of ndarray
+       Spherical harmonics with `diff_n` derivatives.
+
+    Notes
+    -----
+    There are different conventions for the meanings of the input
+    arguments ``theta`` and ``phi``. In SciPy ``theta`` is the
+    polar angle and ``phi`` is the azimuthal angle. It is common to
+    see the opposite convention, that is, ``theta`` as the azimuthal angle
+    and ``phi`` as the polar angle.
+
+    Note that SciPy's spherical harmonics include the Condon-Shortley
+    phase [2]_ because it is part of `sph_legendre_p`.
+
+    With SciPy's conventions, the first several spherical harmonics
+    are
+
+    .. math::
+
+        Y_0^0(\theta, \phi) &= \frac{1}{2} \sqrt{\frac{1}{\pi}} \\
+        Y_1^{-1}(\theta, \phi) &= \frac{1}{2} \sqrt{\frac{3}{2\pi}}
+                                    e^{-i\phi} \sin(\theta) \\
+        Y_1^0(\theta, \phi) &= \frac{1}{2} \sqrt{\frac{3}{\pi}}
+                                 \cos(\theta) \\
+        Y_1^1(\theta, \phi) &= -\frac{1}{2} \sqrt{\frac{3}{2\pi}}
+                                 e^{i\phi} \sin(\theta).
+
+    References
+    ----------
+    .. [1] Digital Library of Mathematical Functions, 14.30.
+           https://dlmf.nist.gov/14.30
+    .. [2] https://en.wikipedia.org/wiki/Spherical_harmonics#Condon.E2.80.93Shortley_phase
+    """, force_complex_output=True, diff_n=0
+)
+
+
+@sph_harm_y._override_key
+def _(diff_n):
+    diff_n = _nonneg_int_or_fail(diff_n, "diff_n", strict=False)
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 0, 1, and 2,"
+            f" received: {diff_n}."
+        )
+    return diff_n
+
+
+@sph_harm_y._override_finalize_out
+def _(out):
+    if (out.shape[-1] == 1):
+        return out[..., 0, 0]
+
+    if (out.shape[-1] == 2):
+        return out[..., 0, 0], out[..., [1, 0], [0, 1]]
+
+    if (out.shape[-1] == 3):
+        return (out[..., 0, 0], out[..., [1, 0], [0, 1]],
+            out[..., [[2, 1], [1, 0]], [[0, 1], [1, 2]]])
+
+
+sph_harm_y_all = MultiUFunc(
+    sph_harm_y_all,
+    "sph_harm_y_all",
+    """sph_harm_y_all(n, m, theta, phi, *, diff_n=0)
+
+    All spherical harmonics up to the specified degree `n`, order `m`,
+    and all derivatives up to order `diff_n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the harmonics. Must have ``n >= 0``. This is
+        often denoted by ``l`` (lower case L) in descriptions of
+        spherical harmonics.
+    m : int
+        Order of the harmonics.
+    theta : array_like
+        Polar (colatitudinal) coordinate; must be in ``[0, pi]``.
+    phi : array_like
+        Azimuthal (longitudinal) coordinate; must be in ``[0, 2*pi]``.
+    diff_n : int, optional
+        A non-negative integer. Compute and return all derivatives up
+        to order `diff_n`. Default is 0.
+
+    Returns
+    -------
+    ndarray or tuple of ndarray
+        Returns a tuple of length ``diff_n + 1`` (if ``diff_n > 0``). The first
+        entry corresponds to the spherical harmonics, the second entry
+        (if ``diff_n >= 1``) to the gradient, and the third entry
+        (if ``diff_n >= 2``)  to the Hessian matrix. Each entry is an array of
+        shape ``(n + 1, 2 * m + 1, ...)``, where the entry at ``(i, j)``
+        corresponds to degree ``i`` and order ``j`` for all ``0 <= i <= n``
+        and ``-m <= j <= m``.
+
+    See Also
+    --------
+    sph_harm_y
+    """, force_complex_output=True, diff_n=0
+)
+
+
+@sph_harm_y_all._override_key
+def _(diff_n):
+    diff_n = _nonneg_int_or_fail(diff_n, "diff_n", strict=False)
+    if not 0 <= diff_n <= 2:
+        raise ValueError(
+            "diff_n is currently only implemented for orders 2,"
+            f" received: {diff_n}."
+        )
+    return diff_n
+
+
+@sph_harm_y_all._override_ufunc_default_kwargs
+def _(diff_n):
+    return {'axes': [(), ()] + [(0, 1, -2, -1)]}
+
+
+@sph_harm_y_all._override_resolve_out_shapes
+def _(n, m, theta_shape, phi_shape, nout, **kwargs):
+    diff_n = kwargs['diff_n']
+
+    if not isinstance(n, numbers.Integral) or (n < 0):
+        raise ValueError("n must be a non-negative integer.")
+
+    return ((n + 1, 2 * abs(m) + 1) + np.broadcast_shapes(theta_shape, phi_shape) +
+        (diff_n + 1, diff_n + 1),)
+
+
+@sph_harm_y_all._override_finalize_out
+def _(out):
+    if (out.shape[-1] == 1):
+        return out[..., 0, 0]
+
+    if (out.shape[-1] == 2):
+        return out[..., 0, 0], out[..., [1, 0], [0, 1]]
+
+    if (out.shape[-1] == 3):
+        return (out[..., 0, 0], out[..., [1, 0], [0, 1]],
+            out[..., [[2, 1], [1, 0]], [[0, 1], [1, 2]]])

v12x/pylib/scipy/special/_orthogonal.py

@@ -0,0 +1,2856 @@
+"""
+A collection of functions to find the weights and abscissas for
+Gaussian Quadrature.
+
+These calculations are done by finding the eigenvalues of a
+tridiagonal matrix whose entries are dependent on the coefficients
+in the recursion formula for the orthogonal polynomials with the
+corresponding weighting function over the interval.
+
+Many recursion relations for orthogonal polynomials are given:
+
+.. math::
+
+    a1n f_{n+1} (x) = (a2n + a3n x ) f_n (x) - a4n f_{n-1} (x)
+
+The recursion relation of interest is
+
+.. math::
+
+    P_{n+1} (x) = (x - A_n) P_n (x) - B_n P_{n-1} (x)
+
+where :math:`P` has a different normalization than :math:`f`.
+
+The coefficients can be found as:
+
+.. math::
+
+    A_n = -a2n / a3n
+    \\qquad
+    B_n = ( a4n / a3n \\sqrt{h_n-1 / h_n})^2
+
+where
+
+.. math::
+
+    h_n = \\int_a^b w(x) f_n(x)^2
+
+assume:
+
+.. math::
+
+    P_0 (x) = 1
+    \\qquad
+    P_{-1} (x) == 0
+
+For the mathematical background, see [golub.welsch-1969-mathcomp]_ and
+[abramowitz.stegun-1965]_.
+
+References
+----------
+.. [golub.welsch-1969-mathcomp]
+   Golub, Gene H, and John H Welsch. 1969. Calculation of Gauss
+   Quadrature Rules. *Mathematics of Computation* 23, 221-230+s1--s10.
+
+.. [abramowitz.stegun-1965]
+   Abramowitz, Milton, and Irene A Stegun. (1965) *Handbook of
+   Mathematical Functions: with Formulas, Graphs, and Mathematical
+   Tables*. Gaithersburg, MD: National Bureau of Standards.
+   http://www.math.sfu.ca/~cbm/aands/
+
+.. [townsend.trogdon.olver-2014]
+   Townsend, A. and Trogdon, T. and Olver, S. (2014)
+   *Fast computation of Gauss quadrature nodes and
+   weights on the whole real line*. :arXiv:`1410.5286`.
+
+.. [townsend.trogdon.olver-2015]
+   Townsend, A. and Trogdon, T. and Olver, S. (2015)
+   *Fast computation of Gauss quadrature nodes and
+   weights on the whole real line*.
+   IMA Journal of Numerical Analysis
+   :doi:`10.1093/imanum/drv002`.
+"""
+#
+# Author:  Travis Oliphant 2000
+# Updated Sep. 2003 (fixed bugs --- tested to be accurate)
+
+# SciPy imports.
+import numpy as np
+from numpy import (exp, inf, pi, sqrt, floor, sin, cos, around,
+                   hstack, arccos, arange)
+from scipy.special import airy
+
+# Local imports.
+# There is no .pyi file for _specfun
+from . import _specfun  # type: ignore
+from . import _ufuncs
+_gam = _ufuncs.gamma
+
+_polyfuns = ['legendre', 'chebyt', 'chebyu', 'chebyc', 'chebys',
+             'jacobi', 'laguerre', 'genlaguerre', 'hermite',
+             'hermitenorm', 'gegenbauer', 'sh_legendre', 'sh_chebyt',
+             'sh_chebyu', 'sh_jacobi']
+
+# Correspondence between new and old names of root functions
+_rootfuns_map = {'roots_legendre': 'p_roots',
+                 'roots_chebyt': 't_roots',
+                 'roots_chebyu': 'u_roots',
+                 'roots_chebyc': 'c_roots',
+                 'roots_chebys': 's_roots',
+                 'roots_jacobi': 'j_roots',
+                 'roots_laguerre': 'l_roots',
+                 'roots_genlaguerre': 'la_roots',
+                 'roots_hermite': 'h_roots',
+                 'roots_hermitenorm': 'he_roots',
+                 'roots_gegenbauer': 'cg_roots',
+                 'roots_sh_legendre': 'ps_roots',
+                 'roots_sh_chebyt': 'ts_roots',
+                 'roots_sh_chebyu': 'us_roots',
+                 'roots_sh_jacobi': 'js_roots'}
+
+__all__ = _polyfuns + list(_rootfuns_map.keys())
+
+
+class orthopoly1d(np.poly1d):
+
+    def __init__(self, roots, weights=None, hn=1.0, kn=1.0, wfunc=None,
+                 limits=None, monic=False, eval_func=None):
+        equiv_weights = [weights[k] / wfunc(roots[k]) for
+                         k in range(len(roots))]
+        mu = sqrt(hn)
+        if monic:
+            evf = eval_func
+            if evf:
+                knn = kn
+                def eval_func(x):
+                    return evf(x) / knn
+            mu = mu / abs(kn)
+            kn = 1.0
+
+        # compute coefficients from roots, then scale
+        poly = np.poly1d(roots, r=True)
+        np.poly1d.__init__(self, poly.coeffs * float(kn))
+
+        self.weights = np.array(list(zip(roots, weights, equiv_weights)))
+        self.weight_func = wfunc
+        self.limits = limits
+        self.normcoef = mu
+
+        # Note: eval_func will be discarded on arithmetic
+        self._eval_func = eval_func
+
+    def __call__(self, v):
+        if self._eval_func and not isinstance(v, np.poly1d):
+            return self._eval_func(v)
+        else:
+            return np.poly1d.__call__(self, v)
+
+    def _scale(self, p):
+        if p == 1.0:
+            return
+        self._coeffs *= p
+
+        evf = self._eval_func
+        if evf:
+            self._eval_func = lambda x: evf(x) * p
+        self.normcoef *= p
+
+
+def _gen_roots_and_weights(n, mu0, an_func, bn_func, f, df, symmetrize, mu):
+    """[x,w] = gen_roots_and_weights(n,an_func,sqrt_bn_func,mu)
+
+    Returns the roots (x) of an nth order orthogonal polynomial,
+    and weights (w) to use in appropriate Gaussian quadrature with that
+    orthogonal polynomial.
+
+    The polynomials have the recurrence relation
+          P_n+1(x) = (x - A_n) P_n(x) - B_n P_n-1(x)
+
+    an_func(n)          should return A_n
+    sqrt_bn_func(n)     should return sqrt(B_n)
+    mu ( = h_0 )        is the integral of the weight over the orthogonal
+                        interval
+    """
+    # lazy import to prevent to prevent linalg dependency for whole module (gh-23420)
+    from scipy import linalg
+    k = np.arange(n, dtype='d')
+    c = np.zeros((2, n))
+    c[0,1:] = bn_func(k[1:])
+    c[1,:] = an_func(k)
+    x = linalg.eigvals_banded(c, overwrite_a_band=True)
+
+    # improve roots by one application of Newton's method
+    y = f(n, x)
+    dy = df(n, x)
+    x -= y/dy
+
+    # fm and dy may contain very large/small values, so we
+    # log-normalize them to maintain precision in the product fm*dy
+    fm = f(n-1, x)
+    log_fm = np.log(np.abs(fm))
+    log_dy = np.log(np.abs(dy))
+    fm /= np.exp((log_fm.max() + log_fm.min()) / 2.)
+    dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)
+    w = 1.0 / (fm * dy)
+
+    if symmetrize:
+        w = (w + w[::-1]) / 2
+        x = (x - x[::-1]) / 2
+
+    w *= mu0 / w.sum()
+
+    if mu:
+        return x, w, mu0
+    else:
+        return x, w
+
+# Jacobi Polynomials 1               P^(alpha,beta)_n(x)
+
+
+def roots_jacobi(n, alpha, beta, mu=False):
+    r"""Gauss-Jacobi quadrature.
+
+    Compute the sample points and weights for Gauss-Jacobi
+    quadrature. The sample points are the roots of the nth degree
+    Jacobi polynomial, :math:`P^{\alpha, \beta}_n(x)`. These sample
+    points and weights correctly integrate polynomials of degree
+    :math:`2n - 1` or less over the interval :math:`[-1, 1]` with
+    weight function :math:`w(x) = (1 - x)^{\alpha} (1 +
+    x)^{\beta}`. See 22.2.1 in [AS]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order.
+    alpha : float
+        alpha must be > -1.
+    beta : float
+        beta must be > -1.
+    mu : bool, optional
+        If True, return the sum of the weights in addition to sample points and weights.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points.
+    w : ndarray
+        Weights.
+    mu : float, optional
+        Sum of the weights, only returned if `mu=True`.
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    >>> from scipy.special import roots_jacobi
+    >>> x, w = roots_jacobi(3, 0.5, 0.5)
+    >>> x
+    array([-0.70710678,  0.        ,  0.70710678])
+    >>> w
+    array([0.39269908, 0.78539816, 0.39269908])
+
+    >>> x, w, mu = roots_jacobi(3, 0.5, 0.5, mu=True)
+    >>> mu
+    1.5707963267948966  # Sum of weights, equals pi/2 for alpha = beta = 0.5
+    """
+
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError("n must be a positive integer.")
+    if alpha <= -1 or beta <= -1:
+        raise ValueError("alpha and beta must be greater than -1.")
+
+    if alpha == 0.0 and beta == 0.0:
+        return roots_legendre(m, mu)
+    if alpha == beta:
+        return roots_gegenbauer(m, alpha+0.5, mu)
+
+    if (alpha + beta) <= 1000:
+        mu0 = 2.0**(alpha+beta+1) * _ufuncs.beta(alpha+1, beta+1)
+    else:
+        # Avoid overflows in pow and beta for very large parameters
+        mu0 = np.exp((alpha + beta + 1) * np.log(2.0)
+                     + _ufuncs.betaln(alpha+1, beta+1))
+    a = alpha
+    b = beta
+    if a + b == 0.0:
+        def an_func(k):
+            return np.where(k == 0, (b - a) / (2 + a + b), 0.0)
+    else:
+        def an_func(k):
+            return np.where(
+                k == 0,
+                (b - a) / (2 + a + b),
+                (b * b - a * a) / ((2.0 * k + a + b) * (2.0 * k + a + b + 2))
+            )
+
+    def bn_func(k):
+        return (
+            2.0 / (2.0 * k + a + b)
+            * np.sqrt((k + a) * (k + b) / (2 * k + a + b + 1))
+            * np.where(k == 1, 1.0, np.sqrt(k * (k + a + b) / (2.0 * k + a + b - 1)))
+        )
+
+    def f(n, x):
+        return _ufuncs.eval_jacobi(n, a, b, x)
+    def df(n, x):
+        return 0.5 * (n + a + b + 1) * _ufuncs.eval_jacobi(n - 1, a + 1, b + 1, x)
+    return _gen_roots_and_weights(m, mu0, an_func, bn_func, f, df, False, mu)
+
+
+def jacobi(n, alpha, beta, monic=False):
+    r"""Jacobi polynomial.
+
+    Defined to be the solution of
+
+    .. math::
+
+        \begin{aligned}
+        (1 - x^2)\frac{d^2}{dx^2} P_n^{(\alpha, \beta)}(x)
+        &+ \left(\beta - \alpha - (\alpha + \beta + 2)x\right)
+        \frac{d}{dx} P_n^{(\alpha, \beta)}(x) \\
+        &+ n(n + \alpha + \beta + 1) P_n^{(\alpha, \beta)}(x) = 0
+        \end{aligned}
+
+    for :math:`\alpha, \beta > -1`; :math:`P_n^{(\alpha, \beta)}` is a
+    polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    alpha : float
+        Parameter, must be greater than -1.
+    beta : float
+        Parameter, must be greater than -1.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    P : orthopoly1d
+        Jacobi polynomial.
+
+    Notes
+    -----
+    For fixed :math:`\alpha, \beta`, the polynomials
+    :math:`P_n^{(\alpha, \beta)}` are orthogonal over :math:`[-1, 1]`
+    with weight function :math:`(1 - x)^\alpha(1 + x)^\beta`.
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The Jacobi polynomials satisfy the recurrence relation:
+
+    .. math::
+        P_n^{(\alpha, \beta-1)}(x) - P_n^{(\alpha-1, \beta)}(x)
+          = P_{n-1}^{(\alpha, \beta)}(x)
+
+    This can be verified, for example, for :math:`\alpha = \beta = 2`
+    and :math:`n = 1` over the interval :math:`[-1, 1]`:
+
+    >>> import numpy as np
+    >>> from scipy.special import jacobi
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> np.allclose(jacobi(0, 2, 2)(x),
+    ...             jacobi(1, 2, 1)(x) - jacobi(1, 1, 2)(x))
+    True
+
+    Plot of the Jacobi polynomial :math:`P_5^{(\alpha, -0.5)}` for
+    different values of :math:`\alpha`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-2.0, 2.0)
+    >>> ax.set_title(r'Jacobi polynomials $P_5^{(\alpha, -0.5)}$')
+    >>> for alpha in np.arange(0, 4, 1):
+    ...     ax.plot(x, jacobi(5, alpha, -0.5)(x), label=rf'$\alpha={alpha}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    def wfunc(x):
+        return (1 - x) ** alpha * (1 + x) ** beta
+    if n == 0:
+        return orthopoly1d([], [], 1.0, 1.0, wfunc, (-1, 1), monic,
+                           eval_func=np.ones_like)
+    x, w, mu = roots_jacobi(n, alpha, beta, mu=True)
+    ab1 = alpha + beta + 1.0
+    hn = 2**ab1 / (2 * n + ab1) * _gam(n + alpha + 1)
+    hn *= _gam(n + beta + 1.0) / _gam(n + 1) / _gam(n + ab1)
+    kn = _gam(2 * n + ab1) / 2.0**n / _gam(n + 1) / _gam(n + ab1)
+    # here kn = coefficient on x^n term
+    p = orthopoly1d(x, w, hn, kn, wfunc, (-1, 1), monic,
+                    lambda x: _ufuncs.eval_jacobi(n, alpha, beta, x))
+    return p
+
+# Jacobi Polynomials shifted         G_n(p,q,x)
+
+
+def roots_sh_jacobi(n, p1, q1, mu=False):
+    """Gauss-Jacobi (shifted) quadrature.
+
+    Compute the sample points and weights for Gauss-Jacobi (shifted)
+    quadrature. The sample points are the roots of the nth degree
+    shifted Jacobi polynomial, :math:`G^{p,q}_n(x)`. These sample
+    points and weights correctly integrate polynomials of degree
+    :math:`2n - 1` or less over the interval :math:`[0, 1]` with
+    weight function :math:`w(x) = (1 - x)^{p-q} x^{q-1}`. See 22.2.2
+    in [AS]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order.
+    p1 : float
+        (p1 - q1) must be > -1.
+    q1 : float
+        q1 must be > 0.
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    if (p1-q1) <= -1 or q1 <= 0:
+        message = "(p - q) must be greater than -1, and q must be greater than 0."
+        raise ValueError(message)
+    x, w, m = roots_jacobi(n, p1-q1, q1-1, True)
+    x = (x + 1) / 2
+    scale = 2.0**p1
+    w /= scale
+    m /= scale
+    if mu:
+        return x, w, m
+    else:
+        return x, w
+
+
+def sh_jacobi(n, p, q, monic=False):
+    r"""Shifted Jacobi polynomial.
+
+    Defined by
+
+    .. math::
+
+        G_n^{(p, q)}(x)
+          = \binom{2n + p - 1}{n}^{-1}P_n^{(p - q, q - 1)}(2x - 1),
+
+    where :math:`P_n^{(\cdot, \cdot)}` is the nth Jacobi polynomial.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    p : float
+        Parameter, must have :math:`p > q - 1`.
+    q : float
+        Parameter, must be greater than 0.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    G : orthopoly1d
+        Shifted Jacobi polynomial.
+
+    Notes
+    -----
+    For fixed :math:`p, q`, the polynomials :math:`G_n^{(p, q)}` are
+    orthogonal over :math:`[0, 1]` with weight function :math:`(1 -
+    x)^{p - q}x^{q - 1}`.
+
+    Examples
+    --------
+    Evaluate the shifted Jacobi polynomial :math:`G_3^{(2, 1)}` at
+    :math:`x = 0.5`:
+
+    >>> import numpy as np
+    >>> from scipy.special import binom, jacobi, sh_jacobi
+    >>> np.isclose(sh_jacobi(3, 2, 1)(0.5), -3/280)
+    True
+
+    The polynomial is related to the Jacobi polynomial
+    :math:`P_n^{(p - q, q - 1)}`:
+
+    >>> x = np.linspace(0, 1, 5)
+    >>> n, p, q = 3, 2, 1
+    >>> scale = 1 / binom(2*n + p - 1, n)
+    >>> np.allclose(sh_jacobi(n, p, q)(x),
+    ...             scale * jacobi(n, p - q, q - 1)(2*x - 1))
+    True
+
+    Plot :math:`G_3^{(p, 1)}` for several values of :math:`p`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(0, 1, 400)
+    >>> fig, ax = plt.subplots()
+    >>> for p in [1, 2, 3]:
+    ...     ax.plot(x, sh_jacobi(3, p, 1)(x), label=rf"$p={p}$")
+    >>> ax.set_title(r"Shifted Jacobi polynomials $G_3^{(p, 1)}$")
+    >>> ax.set_xlabel("x")
+    >>> ax.legend(loc="best")
+    >>> plt.show()
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    def wfunc(x):
+        return (1.0 - x) ** (p - q) * x ** (q - 1.0)
+    if n == 0:
+        return orthopoly1d([], [], 1.0, 1.0, wfunc, (-1, 1), monic,
+                           eval_func=np.ones_like)
+    n1 = n
+    x, w = roots_sh_jacobi(n1, p, q)
+    hn = _gam(n + 1) * _gam(n + q) * _gam(n + p) * _gam(n + p - q + 1)
+    hn /= (2 * n + p) * (_gam(2 * n + p)**2)
+    # kn = 1.0 in standard form so monic is redundant. Kept for compatibility.
+    kn = 1.0
+    pp = orthopoly1d(x, w, hn, kn, wfunc=wfunc, limits=(0, 1), monic=monic,
+                     eval_func=lambda x: _ufuncs.eval_sh_jacobi(n, p, q, x))
+    return pp
+
+# Generalized Laguerre               L^(alpha)_n(x)
+
+
+def roots_genlaguerre(n, alpha, mu=False):
+    r"""Gauss-generalized Laguerre quadrature.
+
+    Compute the sample points and weights for Gauss-generalized
+    Laguerre quadrature. The sample points are the roots of the nth
+    degree generalized Laguerre polynomial, :math:`L^{\alpha}_n(x)`.
+    These sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[0,
+    \infty]` with weight function :math:`w(x) = x^{\alpha}
+    e^{-x}`. See 22.3.9 in [AS]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    alpha : float
+        alpha must be > -1
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError("n must be a positive integer.")
+    if alpha < -1:
+        raise ValueError("alpha must be greater than -1.")
+
+    mu0 = _ufuncs.gamma(alpha + 1)
+
+    if m == 1:
+        x = np.array([alpha+1.0], 'd')
+        w = np.array([mu0], 'd')
+        if mu:
+            return x, w, mu0
+        else:
+            return x, w
+
+    def an_func(k):
+        return 2 * k + alpha + 1
+    def bn_func(k):
+        return -np.sqrt(k * (k + alpha))
+    def f(n, x):
+        return _ufuncs.eval_genlaguerre(n, alpha, x)
+    def df(n, x):
+        return (n * _ufuncs.eval_genlaguerre(n, alpha, x)
+                - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x
+    return _gen_roots_and_weights(m, mu0, an_func, bn_func, f, df, False, mu)
+
+
+def genlaguerre(n, alpha, monic=False):
+    r"""Generalized (associated) Laguerre polynomial.
+
+    Defined to be the solution of
+
+    .. math::
+        x\frac{d^2}{dx^2}L_n^{(\alpha)}(x)
+          + (\alpha + 1 - x)\frac{d}{dx}L_n^{(\alpha)}(x)
+          + nL_n^{(\alpha)}(x) = 0,
+
+    where :math:`\alpha > -1`; :math:`L_n^{(\alpha)}` is a polynomial
+    of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    alpha : float
+        Parameter, must be greater than -1.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    L : orthopoly1d
+        Generalized Laguerre polynomial.
+
+    See Also
+    --------
+    laguerre : Laguerre polynomial.
+    hyp1f1 : confluent hypergeometric function
+
+    Notes
+    -----
+    For fixed :math:`\alpha`, the polynomials :math:`L_n^{(\alpha)}`
+    are orthogonal over :math:`[0, \infty)` with weight function
+    :math:`e^{-x}x^\alpha`.
+
+    The Laguerre polynomials are the special case where :math:`\alpha
+    = 0`.
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The generalized Laguerre polynomials are closely related to the confluent
+    hypergeometric function :math:`{}_1F_1`:
+
+        .. math::
+            L_n^{(\alpha)}(x) = \binom{n + \alpha}{n} {}_1F_1(-n, \alpha +1, x)
+
+    This can be verified, for example,  for :math:`n = \alpha = 3` over the
+    interval :math:`[-1, 1]`:
+
+    >>> import numpy as np
+    >>> from scipy.special import binom, genlaguerre, hyp1f1
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> np.allclose(genlaguerre(3, 3)(x), binom(6, 3) * hyp1f1(-3, 4, x))
+    True
+
+    This is the plot of the generalized Laguerre polynomials
+    :math:`L_3^{(\alpha)}` for some values of :math:`\alpha`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(-4.0, 12.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-5.0, 10.0)
+    >>> ax.set_title(r'Generalized Laguerre polynomials $L_3^{(\alpha)}$')
+    >>> for alpha in np.arange(0, 5):
+    ...     ax.plot(x, genlaguerre(3, alpha)(x), label=rf"$L_3^{{({alpha})}}$")
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    if alpha <= -1:
+        raise ValueError("alpha must be > -1")
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_genlaguerre(n1, alpha)
+    def wfunc(x):
+        return exp(-x) * x ** alpha
+    if n == 0:
+        x, w = [], []
+    hn = _gam(n + alpha + 1) / _gam(n + 1)
+    kn = (-1)**n / _gam(n + 1)
+    p = orthopoly1d(x, w, hn, kn, wfunc, (0, inf), monic,
+                    lambda x: _ufuncs.eval_genlaguerre(n, alpha, x))
+    return p
+
+# Laguerre                      L_n(x)
+
+
+def roots_laguerre(n, mu=False):
+    r"""Gauss-Laguerre quadrature.
+
+    Compute the sample points and weights for Gauss-Laguerre
+    quadrature. The sample points are the roots of the nth degree
+    Laguerre polynomial, :math:`L_n(x)`. These sample points and
+    weights correctly integrate polynomials of degree :math:`2n - 1`
+    or less over the interval :math:`[0, \infty]` with weight function
+    :math:`w(x) = e^{-x}`. See 22.2.13 in [AS]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+    numpy.polynomial.laguerre.laggauss
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    return roots_genlaguerre(n, 0.0, mu=mu)
+
+
+def laguerre(n, monic=False):
+    r"""Laguerre polynomial.
+
+    Defined to be the solution of
+
+    .. math::
+        x\frac{d^2}{dx^2}L_n(x) + (1 - x)\frac{d}{dx}L_n(x)
+          + nL_n(x) = 0;
+
+    :math:`L_n` is a polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    L : orthopoly1d
+        Laguerre Polynomial.
+
+    See Also
+    --------
+    genlaguerre : Generalized (associated) Laguerre polynomial.
+
+    Notes
+    -----
+    The polynomials :math:`L_n` are orthogonal over :math:`[0,
+    \infty)` with weight function :math:`e^{-x}`.
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The Laguerre polynomials :math:`L_n` are the special case
+    :math:`\alpha = 0` of the generalized Laguerre polynomials
+    :math:`L_n^{(\alpha)}`.
+    Let's verify it on the interval :math:`[-1, 1]`:
+
+    >>> import numpy as np
+    >>> from scipy.special import genlaguerre
+    >>> from scipy.special import laguerre
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> np.allclose(genlaguerre(3, 0)(x), laguerre(3)(x))
+    True
+
+    The polynomials :math:`L_n` also satisfy the recurrence relation:
+
+    .. math::
+        (n + 1)L_{n+1}(x) = (2n +1 -x)L_n(x) - nL_{n-1}(x)
+
+    This can be easily checked on :math:`[0, 1]` for :math:`n = 3`:
+
+    >>> x = np.arange(0.0, 1.0, 0.01)
+    >>> np.allclose(4 * laguerre(4)(x),
+    ...             (7 - x) * laguerre(3)(x) - 3 * laguerre(2)(x))
+    True
+
+    This is the plot of the first few Laguerre polynomials :math:`L_n`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(-1.0, 5.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-5.0, 5.0)
+    >>> ax.set_title(r'Laguerre polynomials $L_n$')
+    >>> for n in np.arange(0, 5):
+    ...     ax.plot(x, laguerre(n)(x), label=rf'$L_{n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_laguerre(n1)
+    if n == 0:
+        x, w = [], []
+    hn = 1.0
+    kn = (-1)**n / _gam(n + 1)
+    p = orthopoly1d(x, w, hn, kn, lambda x: exp(-x), (0, inf), monic,
+                    lambda x: _ufuncs.eval_laguerre(n, x))
+    return p
+
+# Hermite  1                         H_n(x)
+
+
+def roots_hermite(n, mu=False):
+    r"""Gauss-Hermite (physicist's) quadrature.
+
+    Compute the sample points and weights for Gauss-Hermite
+    quadrature. The sample points are the roots of the nth degree
+    Hermite polynomial, :math:`H_n(x)`. These sample points and
+    weights correctly integrate polynomials of degree :math:`2n - 1`
+    or less over the interval :math:`[-\infty, \infty]` with weight
+    function :math:`w(x) = e^{-x^2}`. See 22.2.14 in [AS]_ for
+    details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+    numpy.polynomial.hermite.hermgauss
+    roots_hermitenorm
+
+    Notes
+    -----
+    For small n up to 150 a modified version of the Golub-Welsch
+    algorithm is used. Nodes are computed from the eigenvalue
+    problem and improved by one step of a Newton iteration.
+    The weights are computed from the well-known analytical formula.
+
+    For n larger than 150 an optimal asymptotic algorithm is applied
+    which computes nodes and weights in a numerically stable manner.
+    The algorithm has linear runtime making computation for very
+    large n (several thousand or more) feasible.
+
+    References
+    ----------
+    .. [townsend.trogdon.olver-2014]
+        Townsend, A. and Trogdon, T. and Olver, S. (2014)
+        *Fast computation of Gauss quadrature nodes and
+        weights on the whole real line*. :arXiv:`1410.5286`.
+    .. [townsend.trogdon.olver-2015]
+        Townsend, A. and Trogdon, T. and Olver, S. (2015)
+        *Fast computation of Gauss quadrature nodes and
+        weights on the whole real line*.
+        IMA Journal of Numerical Analysis
+        :doi:`10.1093/imanum/drv002`.
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError("n must be a positive integer.")
+
+    mu0 = np.sqrt(np.pi)
+    if n <= 150:
+        def an_func(k):
+            return 0.0 * k
+        def bn_func(k):
+            return np.sqrt(k / 2.0)
+        f = _ufuncs.eval_hermite
+        def df(n, x):
+            return 2.0 * n * _ufuncs.eval_hermite(n - 1, x)
+        return _gen_roots_and_weights(m, mu0, an_func, bn_func, f, df, True, mu)
+    else:
+        nodes, weights = _roots_hermite_asy(m)
+        if mu:
+            return nodes, weights, mu0
+        else:
+            return nodes, weights
+
+
+def _compute_tauk(n, k, maxit=5):
+    """Helper function for Tricomi initial guesses
+
+    For details, see formula 3.1 in lemma 3.1 in the
+    original paper.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order
+    k : ndarray of type int
+        Index of roots :math:`\tau_k` to compute
+    maxit : int
+        Number of Newton maxit performed, the default
+        value of 5 is sufficient.
+
+    Returns
+    -------
+    tauk : ndarray
+        Roots of equation 3.1
+
+    See Also
+    --------
+    initial_nodes_a
+    roots_hermite_asy
+    """
+    a = n % 2 - 0.5
+    c = (4.0*floor(n/2.0) - 4.0*k + 3.0)*pi / (4.0*floor(n/2.0) + 2.0*a + 2.0)
+    def f(x):
+        return x - sin(x) - c
+    def df(x):
+        return 1.0 - cos(x)
+    xi = 0.5*pi
+    for i in range(maxit):
+        xi = xi - f(xi)/df(xi)
+    return xi
+
+
+def _initial_nodes_a(n, k):
+    r"""Tricomi initial guesses
+
+    Computes an initial approximation to the square of the `k`-th
+    (positive) root :math:`x_k` of the Hermite polynomial :math:`H_n`
+    of order :math:`n`. The formula is the one from lemma 3.1 in the
+    original paper. The guesses are accurate except in the region
+    near :math:`\sqrt{2n + 1}`.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order
+    k : ndarray of type int
+        Index of roots to compute
+
+    Returns
+    -------
+    xksq : ndarray
+        Square of the approximate roots
+
+    See Also
+    --------
+    initial_nodes
+    roots_hermite_asy
+    """
+    tauk = _compute_tauk(n, k)
+    sigk = cos(0.5*tauk)**2
+    a = n % 2 - 0.5
+    nu = 4.0*floor(n/2.0) + 2.0*a + 2.0
+    # Initial approximation of Hermite roots (square)
+    xksq = nu*sigk - 1.0/(3.0*nu) * (5.0/(4.0*(1.0-sigk)**2) - 1.0/(1.0-sigk) - 0.25)
+    return xksq
+
+
+def _initial_nodes_b(n, k):
+    r"""Gatteschi initial guesses
+
+    Computes an initial approximation to the square of the kth
+    (positive) root :math:`x_k` of the Hermite polynomial :math:`H_n`
+    of order :math:`n`. The formula is the one from lemma 3.2 in the
+    original paper. The guesses are accurate in the region just
+    below :math:`\sqrt{2n + 1}`.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order
+    k : ndarray of type int
+        Index of roots to compute
+
+    Returns
+    -------
+    xksq : ndarray
+        Square of the approximate root
+
+    See Also
+    --------
+    initial_nodes
+    roots_hermite_asy
+    """
+    a = n % 2 - 0.5
+    nu = 4.0*floor(n/2.0) + 2.0*a + 2.0
+    # Airy roots by approximation
+    ak = _specfun.airyzo(k.max(), 1)[0][::-1]
+    # Initial approximation of Hermite roots (square)
+    xksq = (nu
+            + 2.0**(2.0/3.0) * ak * nu**(1.0/3.0)
+            + 1.0/5.0 * 2.0**(4.0/3.0) * ak**2 * nu**(-1.0/3.0)
+            + (9.0/140.0 - 12.0/175.0 * ak**3) * nu**(-1.0)
+            + (16.0/1575.0 * ak + 92.0/7875.0 * ak**4) * 2.0**(2.0/3.0) * nu**(-5.0/3.0)
+            - (15152.0/3031875.0 * ak**5 + 1088.0/121275.0 * ak**2)
+              * 2.0**(1.0/3.0) * nu**(-7.0/3.0))
+    return xksq
+
+
+def _initial_nodes(n):
+    """Initial guesses for the Hermite roots
+
+    Computes an initial approximation to the non-negative
+    roots :math:`x_k` of the Hermite polynomial :math:`H_n`
+    of order :math:`n`. The Tricomi and Gatteschi initial
+    guesses are used in the region where they are accurate.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order
+
+    Returns
+    -------
+    xk : ndarray
+        Approximate roots
+
+    See Also
+    --------
+    roots_hermite_asy
+    """
+    # Turnover point
+    # linear polynomial fit to error of 10, 25, 40, ..., 1000 point rules
+    fit = 0.49082003*n - 4.37859653
+    turnover = around(fit).astype(int)
+    # Compute all approximations
+    ia = arange(1, int(floor(n*0.5)+1))
+    ib = ia[::-1]
+    xasq = _initial_nodes_a(n, ia[:turnover+1])
+    xbsq = _initial_nodes_b(n, ib[turnover+1:])
+    # Combine
+    iv = sqrt(hstack([xasq, xbsq]))
+    # Central node is always zero
+    if n % 2 == 1:
+        iv = hstack([0.0, iv])
+    return iv
+
+
+def _pbcf(n, theta):
+    r"""Asymptotic series expansion of parabolic cylinder function
+
+    The implementation is based on sections 3.2 and 3.3 from the
+    original paper. Compared to the published version this code
+    adds one more term to the asymptotic series. The detailed
+    formulas can be found at [parabolic-asymptotics]_. The evaluation
+    is done in a transformed variable :math:`\theta := \arccos(t)`
+    where :math:`t := x / \mu` and :math:`\mu := \sqrt{2n + 1}`.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order
+    theta : ndarray
+        Transformed position variable
+
+    Returns
+    -------
+    U : ndarray
+        Value of the parabolic cylinder function :math:`U(a, \theta)`.
+    Ud : ndarray
+        Value of the derivative :math:`U^{\prime}(a, \theta)` of
+        the parabolic cylinder function.
+
+    See Also
+    --------
+    roots_hermite_asy
+
+    References
+    ----------
+    .. [parabolic-asymptotics]
+       https://dlmf.nist.gov/12.10#vii
+    """
+    st = sin(theta)
+    ct = cos(theta)
+    # https://dlmf.nist.gov/12.10#vii
+    mu = 2.0*n + 1.0
+    # https://dlmf.nist.gov/12.10#E23
+    eta = 0.5*theta - 0.5*st*ct
+    # https://dlmf.nist.gov/12.10#E39
+    zeta = -(3.0*eta/2.0) ** (2.0/3.0)
+    # https://dlmf.nist.gov/12.10#E40
+    phi = (-zeta / st**2) ** (0.25)
+    # Coefficients
+    # https://dlmf.nist.gov/12.10#E43
+    a0 = 1.0
+    a1 = 0.10416666666666666667
+    a2 = 0.08355034722222222222
+    a3 = 0.12822657455632716049
+    a4 = 0.29184902646414046425
+    a5 = 0.88162726744375765242
+    b0 = 1.0
+    b1 = -0.14583333333333333333
+    b2 = -0.09874131944444444444
+    b3 = -0.14331205391589506173
+    b4 = -0.31722720267841354810
+    b5 = -0.94242914795712024914
+    # Polynomials
+    # https://dlmf.nist.gov/12.10#E9
+    # https://dlmf.nist.gov/12.10#E10
+    ctp = ct ** arange(16).reshape((-1,1))
+    u0 = 1.0
+    u1 = (1.0*ctp[3,:] - 6.0*ct) / 24.0
+    u2 = (-9.0*ctp[4,:] + 249.0*ctp[2,:] + 145.0) / 1152.0
+    u3 = (-4042.0*ctp[9,:] + 18189.0*ctp[7,:] - 28287.0*ctp[5,:]
+          - 151995.0*ctp[3,:] - 259290.0*ct) / 414720.0
+    u4 = (72756.0*ctp[10,:] - 321339.0*ctp[8,:] - 154982.0*ctp[6,:]
+          + 50938215.0*ctp[4,:] + 122602962.0*ctp[2,:] + 12773113.0) / 39813120.0
+    u5 = (82393456.0*ctp[15,:] - 617950920.0*ctp[13,:] + 1994971575.0*ctp[11,:]
+          - 3630137104.0*ctp[9,:] + 4433574213.0*ctp[7,:] - 37370295816.0*ctp[5,:]
+          - 119582875013.0*ctp[3,:] - 34009066266.0*ct) / 6688604160.0
+    v0 = 1.0
+    v1 = (1.0*ctp[3,:] + 6.0*ct) / 24.0
+    v2 = (15.0*ctp[4,:] - 327.0*ctp[2,:] - 143.0) / 1152.0
+    v3 = (-4042.0*ctp[9,:] + 18189.0*ctp[7,:] - 36387.0*ctp[5,:] 
+          + 238425.0*ctp[3,:] + 259290.0*ct) / 414720.0
+    v4 = (-121260.0*ctp[10,:] + 551733.0*ctp[8,:] - 151958.0*ctp[6,:]
+          - 57484425.0*ctp[4,:] - 132752238.0*ctp[2,:] - 12118727) / 39813120.0
+    v5 = (82393456.0*ctp[15,:] - 617950920.0*ctp[13,:] + 2025529095.0*ctp[11,:]
+          - 3750839308.0*ctp[9,:] + 3832454253.0*ctp[7,:] + 35213253348.0*ctp[5,:]
+          + 130919230435.0*ctp[3,:] + 34009066266*ct) / 6688604160.0
+    # Airy Evaluation (Bi and Bip unused)
+    Ai, Aip, Bi, Bip = airy(mu**(4.0/6.0) * zeta)
+    # Prefactor for U
+    P = 2.0*sqrt(pi) * mu**(1.0/6.0) * phi
+    # Terms for U
+    # https://dlmf.nist.gov/12.10#E42
+    phip = phi ** arange(6, 31, 6).reshape((-1,1))
+    A0 = b0*u0
+    A1 = (b2*u0 + phip[0,:]*b1*u1 + phip[1,:]*b0*u2) / zeta**3
+    A2 = (b4*u0 + phip[0,:]*b3*u1 + phip[1,:]*b2*u2 + phip[2,:]*b1*u3
+          + phip[3,:]*b0*u4) / zeta**6
+    B0 = -(a1*u0 + phip[0,:]*a0*u1) / zeta**2
+    B1 = -(a3*u0 + phip[0,:]*a2*u1 + phip[1,:]*a1*u2 + phip[2,:]*a0*u3) / zeta**5
+    B2 = -(a5*u0 + phip[0,:]*a4*u1 + phip[1,:]*a3*u2 + phip[2,:]*a2*u3
+           + phip[3,:]*a1*u4 + phip[4,:]*a0*u5) / zeta**8
+    # U
+    # https://dlmf.nist.gov/12.10#E35
+    U = P * (Ai * (A0 + A1/mu**2.0 + A2/mu**4.0) +
+             Aip * (B0 + B1/mu**2.0 + B2/mu**4.0) / mu**(8.0/6.0))
+    # Prefactor for derivative of U
+    Pd = sqrt(2.0*pi) * mu**(2.0/6.0) / phi
+    # Terms for derivative of U
+    # https://dlmf.nist.gov/12.10#E46
+    C0 = -(b1*v0 + phip[0,:]*b0*v1) / zeta
+    C1 = -(b3*v0 + phip[0,:]*b2*v1 + phip[1,:]*b1*v2 + phip[2,:]*b0*v3) / zeta**4
+    C2 = -(b5*v0 + phip[0,:]*b4*v1 + phip[1,:]*b3*v2 + phip[2,:]*b2*v3
+           + phip[3,:]*b1*v4 + phip[4,:]*b0*v5) / zeta**7
+    D0 = a0*v0
+    D1 = (a2*v0 + phip[0,:]*a1*v1 + phip[1,:]*a0*v2) / zeta**3
+    D2 = (a4*v0 + phip[0,:]*a3*v1 + phip[1,:]*a2*v2 + phip[2,:]*a1*v3
+          + phip[3,:]*a0*v4) / zeta**6
+    # Derivative of U
+    # https://dlmf.nist.gov/12.10#E36
+    Ud = Pd * (Ai * (C0 + C1/mu**2.0 + C2/mu**4.0) / mu**(4.0/6.0) +
+               Aip * (D0 + D1/mu**2.0 + D2/mu**4.0))
+    return U, Ud
+
+
+def _newton(n, x_initial, maxit=5):
+    """Newton iteration for polishing the asymptotic approximation
+    to the zeros of the Hermite polynomials.
+
+    Parameters
+    ----------
+    n : int
+        Quadrature order
+    x_initial : ndarray
+        Initial guesses for the roots
+    maxit : int
+        Maximal number of Newton iterations.
+        The default 5 is sufficient, usually
+        only one or two steps are needed.
+
+    Returns
+    -------
+    nodes : ndarray
+        Quadrature nodes
+    weights : ndarray
+        Quadrature weights
+
+    See Also
+    --------
+    roots_hermite_asy
+    """
+    # Variable transformation
+    mu = sqrt(2.0*n + 1.0)
+    t = x_initial / mu
+    theta = arccos(t)
+    # Newton iteration
+    for i in range(maxit):
+        u, ud = _pbcf(n, theta)
+        dtheta = u / (sqrt(2.0) * mu * sin(theta) * ud)
+        theta = theta + dtheta
+        if max(abs(dtheta)) < 1e-14:
+            break
+    # Undo variable transformation
+    x = mu * cos(theta)
+    # Central node is always zero
+    if n % 2 == 1:
+        x[0] = 0.0
+    # Compute weights
+    w = exp(-x**2) / (2.0*ud**2)
+    return x, w
+
+
+def _roots_hermite_asy(n):
+    r"""Gauss-Hermite (physicist's) quadrature for large n.
+
+    Computes the sample points and weights for Gauss-Hermite quadrature.
+    The sample points are the roots of the nth degree Hermite polynomial,
+    :math:`H_n(x)`. These sample points and weights correctly integrate
+    polynomials of degree :math:`2n - 1` or less over the interval
+    :math:`[-\infty, \infty]` with weight function :math:`f(x) = e^{-x^2}`.
+
+    This method relies on asymptotic expansions which work best for n > 150.
+    The algorithm has linear runtime making computation for very large n
+    feasible.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+
+    Returns
+    -------
+    nodes : ndarray
+        Quadrature nodes
+    weights : ndarray
+        Quadrature weights
+
+    See Also
+    --------
+    roots_hermite
+
+    References
+    ----------
+    .. [townsend.trogdon.olver-2014]
+       Townsend, A. and Trogdon, T. and Olver, S. (2014)
+       *Fast computation of Gauss quadrature nodes and
+       weights on the whole real line*. :arXiv:`1410.5286`.
+
+    .. [townsend.trogdon.olver-2015]
+       Townsend, A. and Trogdon, T. and Olver, S. (2015)
+       *Fast computation of Gauss quadrature nodes and
+       weights on the whole real line*.
+       IMA Journal of Numerical Analysis
+       :doi:`10.1093/imanum/drv002`.
+    """
+    iv = _initial_nodes(n)
+    nodes, weights = _newton(n, iv)
+    # Combine with negative parts
+    if n % 2 == 0:
+        nodes = hstack([-nodes[::-1], nodes])
+        weights = hstack([weights[::-1], weights])
+    else:
+        nodes = hstack([-nodes[-1:0:-1], nodes])
+        weights = hstack([weights[-1:0:-1], weights])
+    # Scale weights
+    weights *= sqrt(pi) / sum(weights)
+    return nodes, weights
+
+
+def hermite(n, monic=False):
+    r"""Physicist's Hermite polynomial.
+
+    Defined by
+
+    .. math::
+
+        H_n(x) = (-1)^ne^{x^2}\frac{d^n}{dx^n}e^{-x^2};
+
+    :math:`H_n` is a polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    H : orthopoly1d
+        Physicist's Hermite polynomial.
+
+    Notes
+    -----
+    The polynomials :math:`H_n` are orthogonal over :math:`(-\infty,
+    \infty)` with weight function :math:`e^{-x^2}`.
+
+    Examples
+    --------
+    >>> from scipy import special
+    >>> import matplotlib.pyplot as plt
+    >>> import numpy as np
+
+    >>> p_monic = special.hermite(3, monic=True)
+    >>> p_monic
+    poly1d([ 1. ,  0. , -1.5,  0. ])
+    >>> p_monic(1)
+    -0.49999999999999983
+    >>> x = np.linspace(-3, 3, 400)
+    >>> y = p_monic(x)
+    >>> plt.plot(x, y)
+    >>> plt.title("Monic Hermite polynomial of degree 3")
+    >>> plt.xlabel("x")
+    >>> plt.ylabel("H_3(x)")
+    >>> plt.show()
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_hermite(n1)
+    def wfunc(x):
+        return exp(-x * x)
+    if n == 0:
+        x, w = [], []
+    hn = 2**n * _gam(n + 1) * sqrt(pi)
+    kn = 2**n
+    p = orthopoly1d(x, w, hn, kn, wfunc, (-inf, inf), monic,
+                    lambda x: _ufuncs.eval_hermite(n, x))
+    return p
+
+# Hermite  2                         He_n(x)
+
+
+def roots_hermitenorm(n, mu=False):
+    r"""Gauss-Hermite (statistician's) quadrature.
+
+    Compute the sample points and weights for Gauss-Hermite
+    quadrature. The sample points are the roots of the nth degree
+    Hermite polynomial, :math:`He_n(x)`. These sample points and
+    weights correctly integrate polynomials of degree :math:`2n - 1`
+    or less over the interval :math:`[-\infty, \infty]` with weight
+    function :math:`w(x) = e^{-x^2/2}`. See 22.2.15 in [AS]_ for more
+    details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order.
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points.
+    w : ndarray
+        Weights.
+    mu : float
+        Sum of the weights.
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+    numpy.polynomial.hermite_e.hermegauss
+
+    Notes
+    -----
+    For small n up to 150 a modified version of the Golub-Welsch
+    algorithm is used. Nodes are computed from the eigenvalue
+    problem and improved by one step of a Newton iteration.
+    The weights are computed from the well-known analytical formula.
+
+    For n larger than 150 an optimal asymptotic algorithm is used
+    which computes nodes and weights in a numerical stable manner.
+    The algorithm has linear runtime making computation for very
+    large n (several thousand or more) feasible.
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError("n must be a positive integer.")
+
+    mu0 = np.sqrt(2.0*np.pi)
+    if n <= 150:
+        def an_func(k):
+            return 0.0 * k
+        def bn_func(k):
+            return np.sqrt(k)
+        f = _ufuncs.eval_hermitenorm
+        def df(n, x):
+            return n * _ufuncs.eval_hermitenorm(n - 1, x)
+        return _gen_roots_and_weights(m, mu0, an_func, bn_func, f, df, True, mu)
+    else:
+        nodes, weights = _roots_hermite_asy(m)
+        # Transform
+        nodes *= sqrt(2)
+        weights *= sqrt(2)
+        if mu:
+            return nodes, weights, mu0
+        else:
+            return nodes, weights
+
+
+def hermitenorm(n, monic=False):
+    r"""Probabilist's Hermite polynomial.
+
+    Defined by
+
+    .. math::
+
+        He_n(x) = (-1)^ne^{x^2/2}\frac{d^n}{dx^n}e^{-x^2/2};
+
+    :math:`He_n` is a polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    He : orthopoly1d
+        Probabilist's Hermite polynomial.
+
+    Notes
+    -----
+
+    The polynomials :math:`He_n` are orthogonal over :math:`(-\infty,
+    \infty)` with weight function :math:`e^{-x^2/2}`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.special import hermitenorm
+
+    >>> p_monic = hermitenorm(3)
+    >>> p_monic
+    poly1d([ 1.,  0., -3.,  0.])
+
+    Evaluate the probabilist's Hermite polynomial of degree 3 at x = 1:
+
+    >>> p_monic(1)
+    np.float64(-2.0)
+
+    Plot probabilist's Hermite polynomials of degree 0 to 4:
+    
+    >>> x = np.linspace(-3, 3, 100)
+    >>> fig, ax = plt.subplots()
+    >>> for i in range(5):
+    ...     ax.plot(x, hermitenorm(i)(x), label=f"n={i}")
+    >>> plt.title(f"Probabilist's Hermite polynomials $He_n$")
+    >>> plt.xlabel("x")
+    >>> plt.ylabel(rf"$He_n(x)$")
+    >>> plt.legend(loc="best")
+    >>> plt.show()
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_hermitenorm(n1)
+    def wfunc(x):
+        return exp(-x * x / 2.0)
+    if n == 0:
+        x, w = [], []
+    hn = sqrt(2 * pi) * _gam(n + 1)
+    kn = 1.0
+    p = orthopoly1d(x, w, hn, kn, wfunc=wfunc, limits=(-inf, inf), monic=monic,
+                    eval_func=lambda x: _ufuncs.eval_hermitenorm(n, x))
+    return p
+
+# The remainder of the polynomials can be derived from the ones above.
+
+# Ultraspherical (Gegenbauer)        C^(alpha)_n(x)
+
+
+def roots_gegenbauer(n, alpha, mu=False):
+    r"""Gauss-Gegenbauer quadrature.
+
+    Compute the sample points and weights for Gauss-Gegenbauer
+    quadrature. The sample points are the roots of the nth degree
+    Gegenbauer polynomial, :math:`C^{\alpha}_n(x)`. These sample
+    points and weights correctly integrate polynomials of degree
+    :math:`2n - 1` or less over the interval :math:`[-1, 1]` with
+    weight function :math:`w(x) = (1 - x^2)^{\alpha - 1/2}`. See
+    22.2.3 in [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order.
+    alpha : float
+        alpha must be > -0.5.
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError("n must be a positive integer.")
+    if alpha < -0.5:
+        raise ValueError("alpha must be greater than -0.5.")
+    elif alpha == 0.0:
+        # C(n,0,x) == 0 uniformly, however, as alpha->0, C(n,alpha,x)->T(n,x)
+        # strictly, we should just error out here, since the roots are not
+        # really defined, but we used to return something useful, so let's
+        # keep doing so.
+        return roots_chebyt(n, mu)
+
+    if alpha <= 170:
+        mu0 = (np.sqrt(np.pi) * _ufuncs.gamma(alpha + 0.5)) \
+              / _ufuncs.gamma(alpha + 1)
+    else:
+        # For large alpha we use a Taylor series expansion around inf,
+        # expressed as a 6th order polynomial of a^-1 and using Horner's
+        # method to minimize computation and maximize precision
+        inv_alpha = 1. / alpha
+        coeffs = np.array([0.000207186, -0.00152206, -0.000640869,
+                           0.00488281, 0.0078125, -0.125, 1.])
+        mu0 = coeffs[0]
+        for term in range(1, len(coeffs)):
+            mu0 = mu0 * inv_alpha + coeffs[term]
+        mu0 = mu0 * np.sqrt(np.pi / alpha)
+    def an_func(k):
+        return 0.0 * k
+    def bn_func(k):
+        return np.sqrt(k * (k + 2 * alpha - 1) / (4 * (k + alpha) * (k + alpha - 1)))
+    def f(n, x):
+        return _ufuncs.eval_gegenbauer(n, alpha, x)
+    def df(n, x):
+        return (
+            -n * x * _ufuncs.eval_gegenbauer(n, alpha, x)
+            + (n + 2 * alpha - 1) * _ufuncs.eval_gegenbauer(n - 1, alpha, x)
+        ) / (1 - x ** 2)
+    return _gen_roots_and_weights(m, mu0, an_func, bn_func, f, df, True, mu)
+
+
+def gegenbauer(n, alpha, monic=False):
+    r"""Gegenbauer (ultraspherical) polynomial.
+
+    Defined to be the solution of the second-order linear ordinary differential equation
+
+    .. math::
+        (1 - x^2)\frac{d^2}{dx^2}C_n^{(\alpha)}(x)
+          - (2\alpha + 1)x\frac{d}{dx}C_n^{(\alpha)}(x)
+          + n(n + 2\alpha)C_n^{(\alpha)}(x) = 0
+
+    for :math:`\alpha > -1/2`; :math:`C_n^{(\alpha)}` is a polynomial
+    of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    alpha : float
+        Parameter, must be greater than -0.5.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    C : orthopoly1d
+        Gegenbauer polynomial.
+
+    Notes
+    -----
+    The polynomials :math:`C_n^{(\alpha)}` are orthogonal on
+    :math:`[-1,1]` with respect to the weight function :math:`(1 - x^2)^{(\alpha -
+    1/2)}`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import special
+    >>> import matplotlib.pyplot as plt
+
+    We can initialize a variable ``p`` as a Gegenbauer polynomial using the
+    `gegenbauer` function and evaluate at a point ``x = 1``.
+
+    >>> p = special.gegenbauer(3, 0.5, monic=False)
+    >>> p
+    poly1d([ 2.5,  0. , -1.5,  0. ])
+    >>> p(1)
+    1.0
+
+    To evaluate ``p`` at various points ``x`` in the interval ``(-3, 3)``,
+    simply pass an array ``x`` to ``p`` as follows:
+
+    >>> x = np.linspace(-3, 3, 400)
+    >>> y = p(x)
+
+    We can then visualize ``x, y`` using `matplotlib.pyplot`.
+
+    >>> fig, ax = plt.subplots()
+    >>> ax.plot(x, y)
+    >>> ax.set_title("Gegenbauer (ultraspherical) polynomial of degree 3")
+    >>> ax.set_xlabel("x")
+    >>> ax.set_ylabel(r"$C_3^{(0.5)}(x)$")
+    >>> plt.show()
+
+    """
+    if not np.isfinite(alpha) or alpha <= -0.5 :
+        raise ValueError("`alpha` must be a finite number greater than -1/2")
+    base = jacobi(n, alpha - 0.5, alpha - 0.5, monic=monic)
+    if monic or n == 0:
+        return base
+    #  Abrahmowitz and Stegan 22.5.20
+    factor = (_gam(2*alpha + n) * _gam(alpha + 0.5) /
+              _gam(2*alpha) / _gam(alpha + 0.5 + n))
+    base._scale(factor)
+    base.__dict__['_eval_func'] = lambda x: _ufuncs.eval_gegenbauer(float(n),
+                                                                    alpha, x)
+    return base
+
+# Chebyshev of the first kind: T_n(x) =
+#     n! sqrt(pi) / _gam(n+1./2)* P^(-1/2,-1/2)_n(x)
+# Computed anew.
+
+
+def roots_chebyt(n, mu=False):
+    r"""Gauss-Chebyshev (first kind) quadrature.
+
+    Computes the sample points and weights for Gauss-Chebyshev
+    quadrature. The sample points are the roots of the nth degree
+    Chebyshev polynomial of the first kind, :math:`T_n(x)`. These
+    sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[-1, 1]`
+    with weight function :math:`w(x) = 1/\sqrt{1 - x^2}`. See 22.2.4
+    in [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+    numpy.polynomial.chebyshev.chebgauss
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError('n must be a positive integer.')
+    x = _ufuncs._sinpi(np.arange(-m + 1, m, 2) / (2*m))
+    w = np.full_like(x, pi/m)
+    if mu:
+        return x, w, pi
+    else:
+        return x, w
+
+
+def chebyt(n, monic=False):
+    r"""Chebyshev polynomial of the first kind.
+
+    Defined to be the solution of
+
+    .. math::
+        (1 - x^2)\frac{d^2}{dx^2}T_n(x) - x\frac{d}{dx}T_n(x)
+          + n^2T_n(x) = 0;
+
+    :math:`T_n` is a polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    T : orthopoly1d
+        Chebyshev polynomial of the first kind.
+
+    See Also
+    --------
+    chebyu : Chebyshev polynomial of the second kind.
+
+    Notes
+    -----
+    The polynomials :math:`T_n` are orthogonal over :math:`[-1, 1]`
+    with weight function :math:`(1 - x^2)^{-1/2}`.
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    Chebyshev polynomials of the first kind of order :math:`n` can
+    be obtained as the determinant of specific :math:`n \times n`
+    matrices. As an example we can check how the points obtained from
+    the determinant of the following :math:`3 \times 3` matrix
+    lay exactly on :math:`T_3`:
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.linalg import det
+    >>> from scipy.special import chebyt
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-2.0, 2.0)
+    >>> ax.set_title(r'Chebyshev polynomial $T_3$')
+    >>> ax.plot(x, chebyt(3)(x), label=rf'$T_3$')
+    >>> for p in np.arange(-1.0, 1.0, 0.1):
+    ...     ax.plot(p,
+    ...             det(np.array([[p, 1, 0], [1, 2*p, 1], [0, 1, 2*p]])),
+    ...             'rx')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    They are also related to the Jacobi Polynomials
+    :math:`P_n^{(-0.5, -0.5)}` through the relation:
+
+    .. math::
+        P_n^{(-0.5, -0.5)}(x) = \frac{1}{4^n} \binom{2n}{n} T_n(x)
+
+    Let's verify it for :math:`n = 3`:
+
+    >>> from scipy.special import binom
+    >>> from scipy.special import jacobi
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> np.allclose(jacobi(3, -0.5, -0.5)(x),
+    ...             1/64 * binom(6, 3) * chebyt(3)(x))
+    True
+
+    We can plot the Chebyshev polynomials :math:`T_n` for some values
+    of :math:`n`:
+
+    >>> x = np.arange(-1.5, 1.5, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-4.0, 4.0)
+    >>> ax.set_title(r'Chebyshev polynomials $T_n$')
+    >>> for n in np.arange(2,5):
+    ...     ax.plot(x, chebyt(n)(x), label=rf'$T_n={n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    def wfunc(x):
+        return 1.0 / sqrt(1 - x * x)
+    if n == 0:
+        return orthopoly1d([], [], pi, 1.0, wfunc, (-1, 1), monic,
+                           lambda x: _ufuncs.eval_chebyt(n, x))
+    n1 = n
+    x, w, mu = roots_chebyt(n1, mu=True)
+    hn = pi / 2
+    kn = 2**(n - 1)
+    p = orthopoly1d(x, w, hn, kn, wfunc, (-1, 1), monic,
+                    lambda x: _ufuncs.eval_chebyt(n, x))
+    return p
+
+# Chebyshev of the second kind
+#    U_n(x) = (n+1)! sqrt(pi) / (2*_gam(n+3./2)) * P^(1/2,1/2)_n(x)
+
+
+def roots_chebyu(n, mu=False):
+    r"""Gauss-Chebyshev (second kind) quadrature.
+
+    Computes the sample points and weights for Gauss-Chebyshev
+    quadrature. The sample points are the roots of the nth degree
+    Chebyshev polynomial of the second kind, :math:`U_n(x)`. These
+    sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[-1, 1]`
+    with weight function :math:`w(x) = \sqrt{1 - x^2}`. See 22.2.5 in
+    [AS]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError('n must be a positive integer.')
+    t = np.arange(m, 0, -1) * pi / (m + 1)
+    x = np.cos(t)
+    w = pi * np.sin(t)**2 / (m + 1)
+    if mu:
+        return x, w, pi / 2
+    else:
+        return x, w
+
+
+def chebyu(n, monic=False):
+    r"""Chebyshev polynomial of the second kind.
+
+    Defined to be the solution of
+
+    .. math::
+        (1 - x^2)\frac{d^2}{dx^2}U_n(x) - 3x\frac{d}{dx}U_n(x)
+          + n(n + 2)U_n(x) = 0;
+
+    :math:`U_n` is a polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    U : orthopoly1d
+        Chebyshev polynomial of the second kind.
+
+    See Also
+    --------
+    chebyt : Chebyshev polynomial of the first kind.
+
+    Notes
+    -----
+    The polynomials :math:`U_n` are orthogonal over :math:`[-1, 1]`
+    with weight function :math:`(1 - x^2)^{1/2}`.
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    Chebyshev polynomials of the second kind of order :math:`n` can
+    be obtained as the determinant of specific :math:`n \times n`
+    matrices. As an example we can check how the points obtained from
+    the determinant of the following :math:`3 \times 3` matrix
+    lay exactly on :math:`U_3`:
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.linalg import det
+    >>> from scipy.special import chebyu
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-2.0, 2.0)
+    >>> ax.set_title(r'Chebyshev polynomial $U_3$')
+    >>> ax.plot(x, chebyu(3)(x), label=rf'$U_3$')
+    >>> for p in np.arange(-1.0, 1.0, 0.1):
+    ...     ax.plot(p,
+    ...             det(np.array([[2*p, 1, 0], [1, 2*p, 1], [0, 1, 2*p]])),
+    ...             'rx')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    They satisfy the recurrence relation:
+
+    .. math::
+        U_{2n-1}(x) = 2 T_n(x)U_{n-1}(x)
+
+    where :math:`T_n` is the Chebyshev polynomial of the first kind.
+    Let's verify it for :math:`n = 2`:
+
+    >>> from scipy.special import chebyt
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> np.allclose(chebyu(3)(x), 2 * chebyt(2)(x) * chebyu(1)(x))
+    True
+
+    We can plot the Chebyshev polynomials :math:`U_n` for some values
+    of :math:`n`:
+
+    >>> x = np.arange(-1.0, 1.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-1.5, 1.5)
+    >>> ax.set_title(r'Chebyshev polynomials $U_n$')
+    >>> for n in np.arange(1,5):
+    ...     ax.plot(x, chebyu(n)(x), label=rf'$U_n={n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    base = jacobi(n, 0.5, 0.5, monic=monic)
+    if monic:
+        return base
+    factor = sqrt(pi) / 2.0 * _gam(n + 2) / _gam(n + 1.5)
+    base._scale(factor)
+    return base
+
+# Chebyshev of the first kind        C_n(x)
+
+
+def roots_chebyc(n, mu=False):
+    r"""Gauss-Chebyshev (first kind) quadrature.
+
+    Compute the sample points and weights for Gauss-Chebyshev
+    quadrature. The sample points are the roots of the nth degree
+    Chebyshev polynomial of the first kind, :math:`C_n(x)`. These
+    sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[-2, 2]`
+    with weight function :math:`w(x) = 1 / \sqrt{1 - (x/2)^2}`. See
+    22.2.6 in [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    x, w, m = roots_chebyt(n, True)
+    x *= 2
+    w *= 2
+    m *= 2
+    if mu:
+        return x, w, m
+    else:
+        return x, w
+
+
+def chebyc(n, monic=False):
+    r"""Chebyshev polynomial of the first kind on :math:`[-2, 2]`.
+
+    Defined as :math:`C_n(x) = 2T_n(x/2)`, where :math:`T_n` is the
+    nth Chebyshev polynomial of the first kind.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    C : orthopoly1d
+        Chebyshev polynomial of the first kind on :math:`[-2, 2]`.
+
+    See Also
+    --------
+    chebyt : Chebyshev polynomial of the first kind.
+
+    Notes
+    -----
+    The polynomials :math:`C_n(x)` are orthogonal over :math:`[-2, 2]`
+    with weight function :math:`1/\sqrt{1 - (x/2)^2}`.
+
+    References
+    ----------
+    .. [1] Abramowitz and Stegun, "Handbook of Mathematical Functions"
+           Section 22. National Bureau of Standards, 1972.
+
+    Examples
+    --------
+    Evaluate the Chebyshev polynomial :math:`C_3` at :math:`x = 1`:
+
+    >>> import numpy as np
+    >>> from scipy.special import chebyc, chebyt
+    >>> np.isclose(chebyc(3)(1), -2.0)
+    True
+
+    The polynomial :math:`C_n` is a scaled Chebyshev polynomial of the
+    first kind:
+
+    >>> x = np.linspace(-2, 2, 5)
+    >>> np.allclose(chebyc(3)(x), 2 * chebyt(3)(x/2))
+    True
+
+    Plot :math:`C_n` for several values of :math:`n`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(-2, 2, 400)
+    >>> fig, ax = plt.subplots()
+    >>> for n in range(4):
+    ...     ax.plot(x, chebyc(n)(x), label=rf"$C_{n}$")
+    >>> ax.set_title(r"Chebyshev polynomials $C_n$")
+    >>> ax.set_xlabel("x")
+    >>> ax.legend(loc="best")
+    >>> plt.show()
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_chebyc(n1)
+    if n == 0:
+        x, w = [], []
+    hn = 4 * pi * ((n == 0) + 1)
+    kn = 1.0
+    p = orthopoly1d(x, w, hn, kn,
+                    wfunc=lambda x: 1.0 / sqrt(1 - x * x / 4.0),
+                    limits=(-2, 2), monic=monic)
+    if not monic:
+        p._scale(2.0 / p(2))
+        p.__dict__['_eval_func'] = lambda x: _ufuncs.eval_chebyc(n, x)
+    return p
+
+# Chebyshev of the second kind       S_n(x)
+
+
+def roots_chebys(n, mu=False):
+    r"""Gauss-Chebyshev (second kind) quadrature.
+
+    Compute the sample points and weights for Gauss-Chebyshev
+    quadrature. The sample points are the roots of the nth degree
+    Chebyshev polynomial of the second kind, :math:`S_n(x)`. These
+    sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[-2, 2]`
+    with weight function :math:`w(x) = \sqrt{1 - (x/2)^2}`. See 22.2.7
+    in [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    x, w, m = roots_chebyu(n, True)
+    x *= 2
+    w *= 2
+    m *= 2
+    if mu:
+        return x, w, m
+    else:
+        return x, w
+
+
+def chebys(n, monic=False):
+    r"""Chebyshev polynomial of the second kind on :math:`[-2, 2]`.
+
+    Defined as :math:`S_n(x) = U_n(x/2)` where :math:`U_n` is the
+    nth Chebyshev polynomial of the second kind.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    S : orthopoly1d
+        Chebyshev polynomial of the second kind on :math:`[-2, 2]`.
+
+    See Also
+    --------
+    chebyu : Chebyshev polynomial of the second kind
+
+    Notes
+    -----
+    The polynomials :math:`S_n(x)` are orthogonal over :math:`[-2, 2]`
+    with weight function :math:`\sqrt{1 - (x/2)^2}`.
+
+    References
+    ----------
+    .. [1] Abramowitz and Stegun, "Handbook of Mathematical Functions"
+           Section 22. National Bureau of Standards, 1972.
+
+    Examples
+    --------
+    Evaluate the Chebyshev polynomial of the second kind :math:`S_3` at :math:`x = 1`:
+
+    >>> import numpy as np
+    >>> from scipy.special import chebys, chebyu
+    >>> np.isclose(chebys(3)(1), -1.0)
+    True
+
+    The polynomial :math:`S_n` is a scaled Chebyshev polynomial of the
+    second kind:
+
+    >>> x = np.linspace(-2, 2, 5)
+    >>> np.allclose(chebys(3)(x), chebyu(3)(x/2))
+    True
+
+    Plot :math:`S_n` for several values of :math:`n`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(-2, 2, 400)
+    >>> fig, ax = plt.subplots()
+    >>> for n in range(4):
+    ...     ax.plot(x, chebys(n)(x), label=rf"$S_{n}$")
+    >>> ax.set_title(r"Chebyshev polynomials $S_n$")
+    >>> ax.set_xlabel("x")
+    >>> ax.legend(loc="best")
+    >>> plt.show()
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_chebys(n1)
+    if n == 0:
+        x, w = [], []
+    hn = pi
+    kn = 1.0
+    p = orthopoly1d(x, w, hn, kn,
+                    wfunc=lambda x: sqrt(1 - x * x / 4.0),
+                    limits=(-2, 2), monic=monic)
+    if not monic:
+        factor = (n + 1.0) / p(2)
+        p._scale(factor)
+        p.__dict__['_eval_func'] = lambda x: _ufuncs.eval_chebys(n, x)
+    return p
+
+# Shifted Chebyshev of the first kind     T^*_n(x)
+
+
+def roots_sh_chebyt(n, mu=False):
+    r"""Gauss-Chebyshev (first kind, shifted) quadrature.
+
+    Compute the sample points and weights for Gauss-Chebyshev
+    quadrature. The sample points are the roots of the nth degree
+    shifted Chebyshev polynomial of the first kind, :math:`T_n(x)`.
+    These sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[0, 1]`
+    with weight function :math:`w(x) = 1/\sqrt{x - x^2}`. See 22.2.8
+    in [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order.
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points.
+    w : ndarray
+        Weights.
+    mu : float
+        Sum of the weights.
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    xw = roots_chebyt(n, mu)
+    return ((xw[0] + 1) / 2,) + xw[1:]
+
+
+def sh_chebyt(n, monic=False):
+    r"""Shifted Chebyshev polynomial of the first kind.
+
+    Defined as :math:`T^*_n(x) = T_n(2x - 1)` for :math:`T_n` the nth
+    Chebyshev polynomial of the first kind.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    T : orthopoly1d
+        Shifted Chebyshev polynomial of the first kind.
+
+    Notes
+    -----
+    The polynomials :math:`T^*_n` are orthogonal over :math:`[0, 1]`
+    with weight function :math:`(x - x^2)^{-1/2}`.
+
+    Examples
+    --------
+    Evaluate the shifted Chebyshev polynomial of the first kind :math:`T^*_3` at
+    :math:`x = 0.75`:
+
+    >>> import numpy as np
+    >>> from scipy.special import chebyt, sh_chebyt
+    >>> np.isclose(sh_chebyt(3)(0.75), -1.0)
+    True
+
+    The polynomial :math:`T^*_n` is the Chebyshev polynomial
+    :math:`T_n` shifted from :math:`[-1, 1]` to :math:`[0, 1]`:
+
+    >>> x = np.linspace(0, 1, 5)
+    >>> np.allclose(sh_chebyt(3)(x), chebyt(3)(2*x - 1))
+    True
+
+    Plot :math:`T^*_n` for several values of :math:`n`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(0, 1, 400)
+    >>> fig, ax = plt.subplots()
+    >>> for n in range(4):
+    ...     ax.plot(x, sh_chebyt(n)(x), label=rf"$T^*_{n}$")
+    >>> ax.set_title(r"Shifted Chebyshev polynomials $T^*_n$")
+    >>> ax.set_xlabel("x")
+    >>> ax.legend(loc="best")
+    >>> plt.show()
+
+    """
+    base = sh_jacobi(n, 0.0, 0.5, monic=monic)
+    if monic:
+        return base
+    if n > 0:
+        factor = 4**n / 2.0
+    else:
+        factor = 1.0
+    base._scale(factor)
+    return base
+
+
+# Shifted Chebyshev of the second kind    U^*_n(x)
+def roots_sh_chebyu(n, mu=False):
+    r"""Gauss-Chebyshev (second kind, shifted) quadrature.
+
+    Computes the sample points and weights for Gauss-Chebyshev
+    quadrature. The sample points are the roots of the nth degree
+    shifted Chebyshev polynomial of the second kind, :math:`U_n(x)`.
+    These sample points and weights correctly integrate polynomials of
+    degree :math:`2n - 1` or less over the interval :math:`[0, 1]`
+    with weight function :math:`w(x) = \sqrt{x - x^2}`. See 22.2.9 in
+    [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    """
+    x, w, m = roots_chebyu(n, True)
+    x = (x + 1) / 2
+    m_us = _ufuncs.beta(1.5, 1.5)
+    w *= m_us / m
+    if mu:
+        return x, w, m_us
+    else:
+        return x, w
+
+
+def sh_chebyu(n, monic=False):
+    r"""Shifted Chebyshev polynomial of the second kind.
+
+    Defined as :math:`U^*_n(x) = U_n(2x - 1)` for :math:`U_n` the nth
+    Chebyshev polynomial of the second kind.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    U : orthopoly1d
+        Shifted Chebyshev polynomial of the second kind.
+
+    Notes
+    -----
+    The polynomials :math:`U^*_n` are orthogonal over :math:`[0, 1]`
+    with weight function :math:`(x - x^2)^{1/2}`.
+
+    Examples
+    --------
+    Evaluate the shifted Chebyshev polynomial of the second kind :math:`U^*_3` at
+    :math:`x = 0.75`:
+
+    >>> import numpy as np
+    >>> from scipy.special import chebyu, sh_chebyu
+    >>> np.isclose(sh_chebyu(3)(0.75), -1.0)
+    True
+
+    The polynomial :math:`U^*_n` is the Chebyshev polynomial
+    :math:`U_n` shifted from :math:`[-1, 1]` to :math:`[0, 1]`:
+
+    >>> x = np.linspace(0, 1, 5)
+    >>> np.allclose(sh_chebyu(3)(x), chebyu(3)(2*x - 1))
+    True
+
+    Plot :math:`U^*_n` for several values of :math:`n`:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(0, 1, 400)
+    >>> fig, ax = plt.subplots()
+    >>> for n in range(4):
+    ...     ax.plot(x, sh_chebyu(n)(x), label=rf"$U^*_{n}$")
+    >>> ax.set_title(r"Shifted Chebyshev polynomials $U^*_n$")
+    >>> ax.set_xlabel("x")
+    >>> ax.legend(loc="best")
+    >>> plt.show()
+
+    """
+    base = sh_jacobi(n, 2.0, 1.5, monic=monic)
+    if monic:
+        return base
+    factor = 4**n
+    base._scale(factor)
+    return base
+
+# Legendre
+
+
+def roots_legendre(n, mu=False):
+    r"""Gauss-Legendre quadrature.
+
+    Compute the sample points and weights for Gauss-Legendre
+    quadrature [GL]_. The sample points are the roots of the nth degree
+    Legendre polynomial :math:`P_n(x)`. These sample points and
+    weights correctly integrate polynomials of degree :math:`2n - 1`
+    or less over the interval :math:`[-1, 1]` with weight function
+    :math:`w(x) = 1`. See 2.2.10 in [AS]_ for more details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order.
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points.
+    w : ndarray
+        Weights.
+    mu : float
+        Sum of the weights.
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+    numpy.polynomial.legendre.leggauss
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+    .. [GL] Gauss-Legendre quadrature, Wikipedia,
+        https://en.wikipedia.org/wiki/Gauss%E2%80%93Legendre_quadrature
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.special import roots_legendre, eval_legendre
+    >>> roots, weights = roots_legendre(9)
+
+    ``roots`` holds the roots, and ``weights`` holds the weights for
+    Gauss-Legendre quadrature.
+
+    >>> roots
+    array([-0.96816024, -0.83603111, -0.61337143, -0.32425342,  0.        ,
+            0.32425342,  0.61337143,  0.83603111,  0.96816024])
+    >>> weights
+    array([0.08127439, 0.18064816, 0.2606107 , 0.31234708, 0.33023936,
+           0.31234708, 0.2606107 , 0.18064816, 0.08127439])
+
+    Verify that we have the roots by evaluating the degree 9 Legendre
+    polynomial at ``roots``.  All the values are approximately zero:
+
+    >>> eval_legendre(9, roots)
+    array([-8.88178420e-16, -2.22044605e-16,  1.11022302e-16,  1.11022302e-16,
+            0.00000000e+00, -5.55111512e-17, -1.94289029e-16,  1.38777878e-16,
+           -8.32667268e-17])
+
+    Here we'll show how the above values can be used to estimate the
+    integral from 1 to 2 of f(t) = t + 1/t with Gauss-Legendre
+    quadrature [GL]_.  First define the function and the integration
+    limits.
+
+    >>> def f(t):
+    ...    return t + 1/t
+    ...
+    >>> a = 1
+    >>> b = 2
+
+    We'll use ``integral(f(t), t=a, t=b)`` to denote the definite integral
+    of f from t=a to t=b.  The sample points in ``roots`` are from the
+    interval [-1, 1], so we'll rewrite the integral with the simple change
+    of variable::
+
+        x = 2/(b - a) * t - (a + b)/(b - a)
+
+    with inverse::
+
+        t = (b - a)/2 * x + (a + b)/2
+
+    Then::
+
+        integral(f(t), a, b) =
+            (b - a)/2 * integral(f((b-a)/2*x + (a+b)/2), x=-1, x=1)
+
+    We can approximate the latter integral with the values returned
+    by `roots_legendre`.
+
+    Map the roots computed above from [-1, 1] to [a, b].
+
+    >>> t = (b - a)/2 * roots + (a + b)/2
+
+    Approximate the integral as the weighted sum of the function values.
+
+    >>> (b - a)/2 * f(t).dot(weights)
+    2.1931471805599276
+
+    Compare that to the exact result, which is 3/2 + log(2):
+
+    >>> 1.5 + np.log(2)
+    2.1931471805599454
+
+    """
+    m = int(n)
+    if n < 1 or n != m:
+        raise ValueError("n must be a positive integer.")
+
+    mu0 = 2.0
+    def an_func(k):
+        return 0.0 * k
+    def bn_func(k):
+        return k * np.sqrt(1.0 / (4 * k * k - 1))
+    f = _ufuncs.eval_legendre
+    def df(n, x):
+        return (-n * x * _ufuncs.eval_legendre(n, x)
+                + n * _ufuncs.eval_legendre(n - 1, x)) / (1 - x ** 2)
+    return _gen_roots_and_weights(m, mu0, an_func, bn_func, f, df, True, mu)
+
+
+def legendre(n, monic=False):
+    r"""Legendre polynomial.
+
+    Defined to be the solution of
+
+    .. math::
+        \frac{d}{dx}\left[(1 - x^2)\frac{d}{dx}P_n(x)\right]
+          + n(n + 1)P_n(x) = 0;
+
+    :math:`P_n(x)` is a polynomial of degree :math:`n`.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    P : orthopoly1d
+        Legendre polynomial.
+
+    Notes
+    -----
+    The polynomials :math:`P_n` are orthogonal over :math:`[-1, 1]`
+    with weight function 1.
+
+    Examples
+    --------
+    Generate the 3rd-order Legendre polynomial 1/2*(5x^3 + 0x^2 - 3x + 0):
+
+    >>> from scipy.special import legendre
+    >>> legendre(3)
+    poly1d([ 2.5,  0. , -1.5,  0. ])
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    if n == 0:
+        n1 = n + 1
+    else:
+        n1 = n
+    x, w = roots_legendre(n1)
+    if n == 0:
+        x, w = [], []
+    hn = 2.0 / (2 * n + 1)
+    kn = _gam(2 * n + 1) / _gam(n + 1)**2 / 2.0**n
+    p = orthopoly1d(x, w, hn, kn, wfunc=lambda x: 1.0, limits=(-1, 1),
+                    monic=monic,
+                    eval_func=lambda x: _ufuncs.eval_legendre(n, x))
+    return p
+
+# Shifted Legendre              P^*_n(x)
+
+
+def roots_sh_legendre(n, mu=False):
+    r"""Gauss-Legendre (shifted) quadrature.
+
+    Compute the sample points and weights for Gauss-Legendre
+    quadrature. The sample points are the roots of the nth degree
+    shifted Legendre polynomial :math:`P^*_n(x)`. These sample points
+    and weights correctly integrate polynomials of degree :math:`2n -
+    1` or less over the interval :math:`[0, 1]` with weight function
+    :math:`w(x) = 1.0`. See 2.2.11 in [AS]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        quadrature order
+    mu : bool, optional
+        If True, return the sum of the weights, optional.
+
+    Returns
+    -------
+    x : ndarray
+        Sample points
+    w : ndarray
+        Weights
+    mu : float
+        Sum of the weights
+
+    See Also
+    --------
+    scipy.integrate.fixed_quad
+
+    References
+    ----------
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+
+    Compute nodes and weights for a 7th-order shifted Gauss-Legendre quadrature:
+
+    >>> from scipy.special import roots_sh_legendre, eval_sh_legendre
+    >>> x, w = roots_sh_legendre(7)
+    >>> x
+    array([0.02544604, 0.12923441, 0.29707742, 0.5, 0.70292258, 0.87076559,
+        0.97455396])
+    >>> w
+    array([0.06474248, 0.1398527, 0.19091503, 0.20897959, 0.19091503, 0.1398527,
+        0.06474248])
+
+    Verify that ``x`` are the roots of the degree-7 shifted Legendre polynomial:
+
+    >>> eval_sh_legendre(7, x)
+    array([5.55111512e-16, 1.11022302e-16,  3.33066907e-16,  0.00000000e+00,
+        -2.22044605e-16, -1.11022302e-16, -1.85962357e-15])
+
+    The sum of the weights for shifted Gauss-Legendre quadrature is always 1:
+
+    >>> x, w, mu = roots_sh_legendre(10, mu=True)
+    >>> mu 
+    1.0  # Sum of weights of shifted Gauss-Legendre quadrature is always 1
+
+    """
+    x, w = roots_legendre(n)
+    x = (x + 1) / 2
+    w /= 2
+    if mu:
+        return x, w, 1.0
+    else:
+        return x, w
+
+
+def sh_legendre(n, monic=False):
+    r"""
+    Shifted Legendre polynomial.
+
+    Defined as :math:`P^*_n(x) = P_n(2x - 1)` for :math:`P_n` the nth
+    Legendre polynomial.
+
+    Parameters
+    ----------
+    n : int
+        Degree of the polynomial.
+    monic : bool, optional
+        If `True`, scale the leading coefficient to be 1. Default is
+        `False`.
+
+    Returns
+    -------
+    P : orthopoly1d
+        Shifted Legendre polynomial.
+
+    See Also
+    --------
+    scipy.special.legendre
+    scipy.special.roots_sh_legendre
+
+    Notes
+    -----
+    The polynomials :math:`P^*_n` are orthogonal over :math:`[0, 1]`
+    with weight function 1.
+
+    Examples
+    --------
+    The shifted Legendre polynomials :math:`P_n^*` are related
+    to the non-shifted polynomials :math:`P_n` by
+    :math:`P_n^*(x) = P_n(2x - 1)`. We can verify this on the
+    interval :math:`[0, 1]`:
+
+    >>> import numpy as np
+    >>> from scipy.special import sh_legendre, legendre
+    >>> from scipy.integrate import trapezoid
+    >>> x = np.arange(0.0, 1.0, 0.01)
+    >>> n = 3
+    >>> np.allclose(sh_legendre(n)(x), legendre(n)(2*x - 1))
+    True
+
+    The polynomials :math:`P_n^*` satisfy a recurrence
+    relation obtained by the change of variables
+    :math:`t = 2x - 1` in the standard Legendre recurrence:
+
+    .. math::
+
+        (n+1) P_{n+1}^*(x) = (2n+1)(2x-1)\,P_n^*(x) - n\,P_{n-1}^*(x).
+
+    This can be easily checked on :math:`[0, 1]`
+    for :math:`n = 3`:
+
+    >>> n = 3
+    >>> x = np.linspace(0.0, 1.0, 101)
+    >>> lhs = (n + 1) * sh_legendre(n + 1)(x)
+    >>> rhs = (
+    ...     (2*n + 1) * (2*x - 1) * sh_legendre(n)(x)
+    ...     - n * sh_legendre(n - 1)(x)
+    ... )
+    >>> np.allclose(lhs, rhs)
+    True
+
+    Orthogonality over :math:`[0,1]` with weight 1 can be
+    checked numerically; for example, :math:`P_2^*`
+    is orthogonal to :math:`P_3^*`:
+
+    >>> x = np.linspace(0.0, 1.0, 400)
+    >>> y = sh_legendre(2)(x) * sh_legendre(3)(x)
+    >>> np.isclose(trapezoid(y, x), 0.0, atol=1e-12)
+    True
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative.")
+
+    def wfunc(x):
+        return 0.0 * x + 1.0
+    if n == 0:
+        return orthopoly1d([], [], 1.0, 1.0, wfunc, (0, 1), monic,
+                           lambda x: _ufuncs.eval_sh_legendre(n, x))
+    x, w = roots_sh_legendre(n)
+    hn = 1.0 / (2 * n + 1.0)
+    kn = _gam(2 * n + 1) / _gam(n + 1)**2
+    p = orthopoly1d(x, w, hn, kn, wfunc, limits=(0, 1), monic=monic,
+                    eval_func=lambda x: _ufuncs.eval_sh_legendre(n, x))
+    return p
+
+
+# Make the old root function names an alias for the new ones
+_modattrs = globals()
+for newfun, oldfun in _rootfuns_map.items():
+    _modattrs[oldfun] = _modattrs[newfun]
+    __all__.append(oldfun)

v12x/pylib/scipy/special/_precompute/cosine_cdf.py

@@ -0,0 +1,17 @@
+import mpmath
+
+
+def f(x):
+    return (mpmath.pi + x + mpmath.sin(x)) / (2*mpmath.pi)
+
+
+# Note: 40 digits might be overkill; a few more digits than the default
+# might be sufficient.
+mpmath.mp.dps = 40
+ts = mpmath.taylor(f, -mpmath.pi, 20)
+p, q = mpmath.pade(ts, 9, 10)
+
+p = [float(c) for c in p]
+q = [float(c) for c in q]
+print('p =', p)
+print('q =', q)

v12x/pylib/scipy/special/_precompute/expn_asy.py

@@ -0,0 +1,54 @@
+"""Precompute the polynomials for the asymptotic expansion of the
+generalized exponential integral.
+
+Sources
+-------
+[1] NIST, Digital Library of Mathematical Functions,
+    https://dlmf.nist.gov/8.20#ii
+
+"""
+import os
+
+try:
+    import sympy
+    from sympy import Poly
+    x = sympy.symbols('x')
+except ImportError:
+    pass
+
+
+def generate_A(K):
+    A = [Poly(1, x)]
+    for k in range(K):
+        A.append(Poly(1 - 2*k*x, x)*A[k] + Poly(x*(x + 1))*A[k].diff())
+    return A
+
+
+WARNING = """\
+/* This file was automatically generated by _precompute/expn_asy.py.
+ * Do not edit it manually!
+ */
+"""
+
+
+def main():
+    print(__doc__)
+    fn = os.path.join('..', 'cephes', 'expn.h')
+
+    K = 12
+    A = generate_A(K)
+    with open(fn + '.new', 'w') as f:
+        f.write(WARNING)
+        f.write(f"#define nA {len(A)}\n")
+        for k, Ak in enumerate(A):
+            ', '.join([str(x.evalf(18)) for x in Ak.coeffs()])
+            f.write(f"static const double A{k}[] = {{tmp}};\n")
+        ", ".join([f"A{k}" for k in range(K + 1)])
+        f.write("static const double *A[] = {{tmp}};\n")
+        ", ".join([str(Ak.degree()) for Ak in A])
+        f.write("static const int Adegs[] = {{tmp}};\n")
+    os.rename(fn + '.new', fn)
+
+
+if __name__ == "__main__":
+    main()

v12x/pylib/scipy/special/_precompute/gammainc_asy.py

@@ -0,0 +1,116 @@
+"""
+Precompute coefficients of Temme's asymptotic expansion for gammainc.
+
+This takes about 8 hours to run on a 2.3 GHz Macbook Pro with 4GB ram.
+
+Sources:
+[1] NIST, "Digital Library of Mathematical Functions",
+    https://dlmf.nist.gov/
+
+"""
+import os
+from scipy.special._precompute.utils import lagrange_inversion
+
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+
+def compute_a(n):
+    """a_k from DLMF 5.11.6"""
+    a = [mp.sqrt(2)/2]
+    for k in range(1, n):
+        ak = a[-1]/k
+        for j in range(1, len(a)):
+            ak -= a[j]*a[-j]/(j + 1)
+        ak /= a[0]*(1 + mp.mpf(1)/(k + 1))
+        a.append(ak)
+    return a
+
+
+def compute_g(n):
+    """g_k from DLMF 5.11.3/5.11.5"""
+    a = compute_a(2*n)
+    g = [mp.sqrt(2)*mp.rf(0.5, k)*a[2*k] for k in range(n)]
+    return g
+
+
+def eta(lam):
+    """Function from DLMF 8.12.1 shifted to be centered at 0."""
+    if lam > 0:
+        return mp.sqrt(2*(lam - mp.log(lam + 1)))
+    elif lam < 0:
+        return -mp.sqrt(2*(lam - mp.log(lam + 1)))
+    else:
+        return 0
+
+
+def compute_alpha(n):
+    """alpha_n from DLMF 8.12.13"""
+    coeffs = mp.taylor(eta, 0, n - 1)
+    return lagrange_inversion(coeffs)
+
+
+def compute_d(K, N):
+    """d_{k, n} from DLMF 8.12.12"""
+    M = N + 2*K
+    d0 = [-mp.mpf(1)/3]
+    alpha = compute_alpha(M + 2)
+    for n in range(1, M):
+        d0.append((n + 2)*alpha[n+2])
+    d = [d0]
+    g = compute_g(K)
+    for k in range(1, K):
+        dk = []
+        for n in range(M - 2*k):
+            dk.append((-1)**k*g[k]*d[0][n] + (n + 2)*d[k-1][n+2])
+        d.append(dk)
+    for k in range(K):
+        d[k] = d[k][:N]
+    return d
+
+
+header = \
+r"""/* This file was automatically generated by _precomp/gammainc.py.
+ * Do not edit it manually!
+ */
+
+#ifndef IGAM_H
+#define IGAM_H
+
+#define K {}
+#define N {}
+
+static const double d[K][N] =
+{{"""
+
+footer = \
+r"""
+#endif
+"""
+
+
+def main():
+    print(__doc__)
+    K = 25
+    N = 25
+    with mp.workdps(50):
+        d = compute_d(K, N)
+    fn = os.path.join(os.path.dirname(__file__), '..', 'cephes', 'igam.h')
+    with open(fn + '.new', 'w') as f:
+        f.write(header.format(K, N))
+        for k, row in enumerate(d):
+            row = [mp.nstr(x, 17, min_fixed=0, max_fixed=0) for x in row]
+            f.write('{')
+            f.write(", ".join(row))
+            if k < K - 1:
+                f.write('},\n')
+            else:
+                f.write('}};\n')
+        f.write(footer)
+    os.rename(fn + '.new', fn)
+
+
+if __name__ == "__main__":
+    main()

v12x/pylib/scipy/special/_precompute/gammainc_data.py

@@ -0,0 +1,124 @@
+"""Compute gammainc and gammaincc for large arguments and parameters
+and save the values to data files for use in tests. We can't just
+compare to mpmath's gammainc in test_mpmath.TestSystematic because it
+would take too long.
+
+Note that mpmath's gammainc is computed using hypercomb, but since it
+doesn't allow the user to increase the maximum number of terms used in
+the series it doesn't converge for many arguments. To get around this
+we copy the mpmath implementation but use more terms.
+
+This takes about 17 minutes to run on a 2.3 GHz Macbook Pro with 4GB
+ram.
+
+Sources:
+[1] Fredrik Johansson and others. mpmath: a Python library for
+    arbitrary-precision floating-point arithmetic (version 0.19),
+    December 2013. http://mpmath.org/.
+
+"""
+import os
+from time import time
+import numpy as np
+from numpy import pi
+
+from scipy.special._mptestutils import mpf2float
+
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+
+def gammainc(a, x, dps=50, maxterms=10**8):
+    """Compute gammainc exactly like mpmath does but allow for more
+    summands in hypercomb. See
+
+    mpmath/functions/expintegrals.py#L134
+
+    in the mpmath GitHub repository.
+
+    """
+    with mp.workdps(dps):
+        z, a, b = mp.mpf(a), mp.mpf(x), mp.mpf(x)
+        G = [z]
+        negb = mp.fneg(b, exact=True)
+
+        def h(z):
+            T1 = [mp.exp(negb), b, z], [1, z, -1], [], G, [1], [1+z], b
+            return (T1,)
+
+        res = mp.hypercomb(h, [z], maxterms=maxterms)
+        return mpf2float(res)
+
+
+def gammaincc(a, x, dps=50, maxterms=10**8):
+    """Compute gammaincc exactly like mpmath does but allow for more
+    terms in hypercomb. See
+
+    mpmath/functions/expintegrals.py#L187
+
+    in the mpmath GitHub repository.
+
+    """
+    with mp.workdps(dps):
+        z, a = a, x
+
+        if mp.isint(z):
+            try:
+                # mpmath has a fast integer path
+                return mpf2float(mp.gammainc(z, a=a, regularized=True))
+            except mp.libmp.NoConvergence:
+                pass
+        nega = mp.fneg(a, exact=True)
+        G = [z]
+        # Use 2F0 series when possible; fall back to lower gamma representation
+        try:
+            def h(z):
+                r = z-1
+                return [([mp.exp(nega), a], [1, r], [], G, [1, -r], [], 1/nega)]
+            return mpf2float(mp.hypercomb(h, [z], force_series=True))
+        except mp.libmp.NoConvergence:
+            def h(z):
+                T1 = [], [1, z-1], [z], G, [], [], 0
+                T2 = [-mp.exp(nega), a, z], [1, z, -1], [], G, [1], [1+z], a
+                return T1, T2
+            return mpf2float(mp.hypercomb(h, [z], maxterms=maxterms))
+
+
+def main():
+    t0 = time()
+    # It would be nice to have data for larger values, but either this
+    # requires prohibitively large precision (dps > 800) or mpmath has
+    # a bug. For example, gammainc(1e20, 1e20, dps=800) returns a
+    # value around 0.03, while the true value should be close to 0.5
+    # (DLMF 8.12.15).
+    print(__doc__)
+    pwd = os.path.dirname(__file__)
+    r = np.logspace(4, 14, 30)
+    ltheta = np.logspace(np.log10(pi/4), np.log10(np.arctan(0.6)), 30)
+    utheta = np.logspace(np.log10(pi/4), np.log10(np.arctan(1.4)), 30)
+
+    regimes = [(gammainc, ltheta), (gammaincc, utheta)]
+    for func, theta in regimes:
+        rg, thetag = np.meshgrid(r, theta)
+        a, x = rg*np.cos(thetag), rg*np.sin(thetag)
+        a, x = a.flatten(), x.flatten()
+        dataset = []
+        for i, (a0, x0) in enumerate(zip(a, x)):
+            if func == gammaincc:
+                # Exploit the fast integer path in gammaincc whenever
+                # possible so that the computation doesn't take too
+                # long
+                a0, x0 = np.floor(a0), np.floor(x0)
+            dataset.append((a0, x0, func(a0, x0)))
+        dataset = np.array(dataset)
+        filename = os.path.join(pwd, '..', 'tests', 'data', 'local',
+                                f'{func.__name__}.txt')
+        np.savetxt(filename, dataset)
+
+    print(f"{(time() - t0)/60} minutes elapsed")
+
+
+if __name__ == "__main__":
+    main()

v12x/pylib/scipy/special/_precompute/hyp2f1_data.py

@@ -0,0 +1,484 @@
+"""This script evaluates scipy's implementation of hyp2f1 against mpmath's.
+
+Author: Albert Steppi
+
+This script is long running and generates a large output file. With default
+arguments, the generated file is roughly 700MB in size and it takes around
+40 minutes using an Intel(R) Core(TM) i5-8250U CPU with n_jobs set to 8
+(full utilization). There are optional arguments which can be used to restrict
+(or enlarge) the computations performed. These are described below.
+The output of this script can be analyzed to identify suitable test cases and
+to find parameter and argument regions where hyp2f1 needs to be improved.
+
+The script has one mandatory positional argument for specifying the path to
+the location where the output file is to be placed, and 4 optional arguments
+--n_jobs, --grid_size, --regions, and --parameter_groups. --n_jobs specifies
+the number of processes to use if running in parallel. The default value is 1.
+The other optional arguments are explained below.
+
+Produces a tab separated values file with 11 columns. The first four columns
+contain the parameters a, b, c and the argument z. The next two contain |z| and
+a region code for which region of the complex plane belongs to. The regions are
+
+    0) z == 1
+    1) |z| < 0.9 and real(z) >= 0
+    2) |z| <= 1 and real(z) < 0
+    3) 0.9 <= |z| <= 1 and |1 - z| < 0.9:
+    4) 0.9 <= |z| <= 1 and |1 - z| >= 0.9 and real(z) >= 0:
+    5) 1 < |z| < 1.1 and |1 - z| >= 0.9 and real(z) >= 0
+    6) |z| > 1 and not in 5)
+
+The --regions optional argument allows the user to specify a list of regions
+to which computation will be restricted.
+
+Parameters a, b, c are taken from a 10 * 10 * 10 grid with values at
+
+    -16, -8, -4, -2, -1, 1, 2, 4, 8, 16
+
+with random perturbations applied.
+
+There are 9 parameter groups handling the following cases.
+
+    1) A, B, C, B - A, C - A, C - B, C - A - B all non-integral.
+    2) B - A integral
+    3) C - A integral
+    4) C - B integral
+    5) C - A - B integral
+    6) A integral
+    7) B integral
+    8) C integral
+    9) Wider range with c - a - b > 0.
+
+The seventh column of the output file is an integer between 1 and 8 specifying
+the parameter group as above.
+
+The --parameter_groups optional argument allows the user to specify a list of
+parameter groups to which computation will be restricted.
+
+The argument z is taken from a grid in the box
+    -box_size <= real(z) <= box_size, -box_size <= imag(z) <= box_size.
+with grid size specified using the optional command line argument --grid_size,
+and box_size specified with the command line argument --box_size.
+The default value of grid_size is 20 and the default value of box_size is 2.0,
+yielding a 20 * 20 grid in the box with corners -2-2j, -2+2j, 2-2j, 2+2j.
+
+The final four columns have the expected value of hyp2f1 for the given
+parameters and argument as calculated with mpmath, the observed value
+calculated with scipy's hyp2f1, the relative error, and the absolute error.
+
+As special cases of hyp2f1 are moved from the original Fortran implementation
+into Cython, this script can be used to ensure that no regressions occur and
+to point out where improvements are needed.
+"""
+
+
+import os
+import csv
+import argparse
+import numpy as np
+from itertools import product
+from multiprocessing import Pool
+
+
+from scipy.special import hyp2f1
+from scipy.special.tests.test_hyp2f1 import mp_hyp2f1
+
+
+def get_region(z):
+    """Assign numbers for regions where hyp2f1 must be handled differently."""
+    if z == 1 + 0j:
+        return 0
+    elif abs(z) < 0.9 and z.real >= 0:
+        return 1
+    elif abs(z) <= 1 and z.real < 0:
+        return 2
+    elif 0.9 <= abs(z) <= 1 and abs(1 - z) < 0.9:
+        return 3
+    elif 0.9 <= abs(z) <= 1 and abs(1 - z) >= 0.9:
+        return 4
+    elif 1 < abs(z) < 1.1 and abs(1 - z) >= 0.9 and z.real >= 0:
+        return 5
+    else:
+        return 6
+
+
+def get_result(a, b, c, z, group):
+    """Get results for given parameter and value combination."""
+    expected, observed = mp_hyp2f1(a, b, c, z), hyp2f1(a, b, c, z)
+    if (
+            np.isnan(observed) and np.isnan(expected) or
+            expected == observed
+    ):
+        relative_error = 0.0
+        absolute_error = 0.0
+    elif np.isnan(observed):
+        # Set error to infinity if result is nan when not expected to be.
+        # Makes results easier to interpret.
+        relative_error = float("inf")
+        absolute_error = float("inf")
+    else:
+        absolute_error = abs(expected - observed)
+        relative_error = absolute_error / abs(expected)
+
+    return (
+        a,
+        b,
+        c,
+        z,
+        abs(z),
+        get_region(z),
+        group,
+        expected,
+        observed,
+        relative_error,
+        absolute_error,
+    )
+
+
+def get_result_no_mp(a, b, c, z, group):
+    """Get results for given parameter and value combination."""
+    expected, observed = complex('nan'), hyp2f1(a, b, c, z)
+    relative_error, absolute_error = float('nan'), float('nan')
+    return (
+        a,
+        b,
+        c,
+        z,
+        abs(z),
+        get_region(z),
+        group,
+        expected,
+        observed,
+        relative_error,
+        absolute_error,
+    )
+
+
+def get_results(params, Z, n_jobs=1, compute_mp=True):
+    """Batch compute results for multiple parameter and argument values.
+
+    Parameters
+    ----------
+    params : iterable
+        iterable of tuples of floats (a, b, c) specifying parameter values
+        a, b, c for hyp2f1
+    Z : iterable of complex
+        Arguments at which to evaluate hyp2f1
+    n_jobs : Optional[int]
+        Number of jobs for parallel execution.
+
+    Returns
+    -------
+    list
+        List of tuples of results values. See return value in source code
+        of `get_result`.
+    """
+    input_ = (
+        (a, b, c, z, group) for (a, b, c, group), z in product(params, Z)
+    )
+
+    with Pool(n_jobs) as pool:
+        rows = pool.starmap(
+            get_result if compute_mp else get_result_no_mp,
+            input_
+        )
+    return rows
+
+
+def _make_hyp2f1_test_case(a, b, c, z, rtol):
+    """Generate string for single test case as used in test_hyp2f1.py."""
+    expected = mp_hyp2f1(a, b, c, z)
+    return (
+        "    pytest.param(\n"
+        "        Hyp2f1TestCase(\n"
+        f"            a={a},\n"
+        f"            b={b},\n"
+        f"            c={c},\n"
+        f"            z={z},\n"
+        f"            expected={expected},\n"
+        f"            rtol={rtol},\n"
+        "        ),\n"
+        "    ),"
+    )
+
+
+def make_hyp2f1_test_cases(rows):
+    """Generate string for a list of test cases for test_hyp2f1.py.
+
+    Parameters
+    ----------
+    rows : list
+        List of lists of the form [a, b, c, z, rtol] where a, b, c, z are
+        parameters and the argument for hyp2f1 and rtol is an expected
+        relative error for the associated test case.
+
+    Returns
+    -------
+    str
+        String for a list of test cases. The output string can be printed
+        or saved to a file and then copied into an argument for
+        `pytest.mark.parameterize` within `scipy.special.tests.test_hyp2f1.py`.
+    """
+    result = "[\n"
+    result += '\n'.join(
+        _make_hyp2f1_test_case(a, b, c, z, rtol)
+        for a, b, c, z, rtol in rows
+    )
+    result += "\n]"
+    return result
+
+
+def main(
+        outpath,
+        n_jobs=1,
+        box_size=2.0,
+        grid_size=20,
+        regions=None,
+        parameter_groups=None,
+        compute_mp=True,
+):
+    outpath = os.path.realpath(os.path.expanduser(outpath))
+
+    random_state = np.random.RandomState(1234)
+    # Parameters a, b, c selected near these values.
+    root_params = np.array(
+        [-16, -8, -4, -2, -1, 1, 2, 4, 8, 16]
+    )
+    # Perturbations to apply to root values.
+    perturbations = 0.1 * random_state.random_sample(
+        size=(3, len(root_params))
+    )
+
+    params = []
+    # Parameter group 1
+    # -----------------
+    # No integer differences. This has been confirmed for the above seed.
+    A = root_params + perturbations[0, :]
+    B = root_params + perturbations[1, :]
+    C = root_params + perturbations[2, :]
+    params.extend(
+        sorted(
+            ((a, b, c, 1) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 2
+    # -----------------
+    # B - A an integer
+    A = root_params + 0.5
+    B = root_params + 0.5
+    C = root_params + perturbations[1, :]
+    params.extend(
+        sorted(
+            ((a, b, c, 2) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 3
+    # -----------------
+    # C - A an integer
+    A = root_params + 0.5
+    B = root_params + perturbations[1, :]
+    C = root_params + 0.5
+    params.extend(
+        sorted(
+            ((a, b, c, 3) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 4
+    # -----------------
+    # C - B an integer
+    A = root_params + perturbations[0, :]
+    B = root_params + 0.5
+    C = root_params + 0.5
+    params.extend(
+        sorted(
+            ((a, b, c, 4) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 5
+    # -----------------
+    # C - A - B an integer
+    A = root_params + 0.25
+    B = root_params + 0.25
+    C = root_params + 0.5
+    params.extend(
+        sorted(
+            ((a, b, c, 5) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 6
+    # -----------------
+    # A an integer
+    A = root_params
+    B = root_params + perturbations[0, :]
+    C = root_params + perturbations[1, :]
+    params.extend(
+        sorted(
+            ((a, b, c, 6) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 7
+    # -----------------
+    # B an integer
+    A = root_params + perturbations[0, :]
+    B = root_params
+    C = root_params + perturbations[1, :]
+    params.extend(
+        sorted(
+            ((a, b, c, 7) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 8
+    # -----------------
+    # C an integer
+    A = root_params + perturbations[0, :]
+    B = root_params + perturbations[1, :]
+    C = root_params
+    params.extend(
+        sorted(
+            ((a, b, c, 8) for a, b, c in product(A, B, C)),
+            key=lambda x: max(abs(x[0]), abs(x[1])),
+        )
+    )
+
+    # Parameter group 9
+    # -----------------
+    # Wide range of magnitudes, c - a - b > 0.
+    phi = (1 + np.sqrt(5))/2
+    P = phi**np.arange(16)
+    P = np.hstack([-P, P])
+    group_9_params = sorted(
+        (
+            (a, b, c, 9) for a, b, c in product(P, P, P) if c - a - b > 0
+        ),
+        key=lambda x: max(abs(x[0]), abs(x[1])),
+    )
+
+    if parameter_groups is not None:
+        # Group 9 params only used if specified in arguments.
+        params.extend(group_9_params)
+        params = [
+            (a, b, c, group) for a, b, c, group in params
+            if group in parameter_groups
+        ]
+
+    # grid_size * grid_size grid in box with corners
+    # -2 - 2j, -2 + 2j, 2 - 2j, 2 + 2j
+    X, Y = np.meshgrid(
+        np.linspace(-box_size, box_size, grid_size),
+        np.linspace(-box_size, box_size, grid_size)
+    )
+    Z = X + Y * 1j
+    Z = Z.flatten().tolist()
+    # Add z = 1 + 0j (region 0).
+    Z.append(1 + 0j)
+    if regions is not None:
+        Z = [z for z in Z if get_region(z) in regions]
+
+    # Evaluate scipy and mpmath's hyp2f1 for all parameter combinations
+    # above against all arguments in the grid Z
+    rows = get_results(params, Z, n_jobs=n_jobs, compute_mp=compute_mp)
+
+    with open(outpath, "w", newline="") as f:
+        writer = csv.writer(f, delimiter="\t")
+        writer.writerow(
+            [
+                "a",
+                "b",
+                "c",
+                "z",
+                "|z|",
+                "region",
+                "parameter_group",
+                "expected",  # mpmath's hyp2f1
+                "observed",  # scipy's hyp2f1
+                "relative_error",
+                "absolute_error",
+            ]
+        )
+        for row in rows:
+            writer.writerow(row)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Test scipy's hyp2f1 against mpmath's on a grid in the"
+        " complex plane over a grid of parameter values. Saves output to file"
+        " specified in positional argument \"outpath\"."
+        " Caution: With default arguments, the generated output file is"
+        " roughly 700MB in size. Script may take several hours to finish if"
+        " \"--n_jobs\" is set to 1."
+    )
+    parser.add_argument(
+        "outpath", type=str, help="Path to output tsv file."
+    )
+    parser.add_argument(
+        "--n_jobs",
+        type=int,
+        default=1,
+        help="Number of jobs for multiprocessing.",
+    )
+    parser.add_argument(
+        "--box_size",
+        type=float,
+        default=2.0,
+        help="hyp2f1 is evaluated in box of side_length 2*box_size centered"
+        " at the origin."
+    )
+    parser.add_argument(
+        "--grid_size",
+        type=int,
+        default=20,
+        help="hyp2f1 is evaluated on grid_size * grid_size grid in box of side"
+        " length 2*box_size centered at the origin."
+    )
+    parser.add_argument(
+        "--parameter_groups",
+        type=int,
+        nargs='+',
+        default=None,
+        help="Restrict to supplied parameter groups. See the Docstring for"
+        " this module for more info on parameter groups. Calculate for all"
+        " parameter groups by default."
+    )
+    parser.add_argument(
+        "--regions",
+        type=int,
+        nargs='+',
+        default=None,
+        help="Restrict to argument z only within the supplied regions. See"
+        " the Docstring for this module for more info on regions. Calculate"
+        " for all regions by default."
+    )
+    parser.add_argument(
+        "--no_mp",
+        action='store_true',
+        help="If this flag is set, do not compute results with mpmath. Saves"
+        " time if results have already been computed elsewhere. Fills in"
+        " \"expected\" column with None values."
+    )
+    args = parser.parse_args()
+    compute_mp = not args.no_mp
+    print(args.parameter_groups)
+    main(
+        args.outpath,
+        n_jobs=args.n_jobs,
+        box_size=args.box_size,
+        grid_size=args.grid_size,
+        parameter_groups=args.parameter_groups,
+        regions=args.regions,
+        compute_mp=compute_mp,
+    )

v12x/pylib/scipy/special/_precompute/lambertw.py

@@ -0,0 +1,68 @@
+"""Compute a Pade approximation for the principal branch of the
+Lambert W function around 0 and compare it to various other
+approximations.
+
+"""
+import numpy as np
+
+try:
+    import mpmath
+    import matplotlib.pyplot as plt
+except ImportError:
+    pass
+
+
+def lambertw_pade():
+    derivs = [mpmath.diff(mpmath.lambertw, 0, n=n) for n in range(6)]
+    p, q = mpmath.pade(derivs, 3, 2)
+    return p, q
+
+
+def main():
+    print(__doc__)
+    with mpmath.workdps(50):
+        p, q = lambertw_pade()
+        p, q = p[::-1], q[::-1]
+        print(f"p = {p}")
+        print(f"q = {q}")
+
+    x, y = np.linspace(-1.5, 1.5, 75), np.linspace(-1.5, 1.5, 75)
+    x, y = np.meshgrid(x, y)
+    z = x + 1j*y
+    lambertw_std = []
+    for z0 in z.flatten():
+        lambertw_std.append(complex(mpmath.lambertw(z0)))
+    lambertw_std = np.array(lambertw_std).reshape(x.shape)
+
+    fig, axes = plt.subplots(nrows=3, ncols=1)
+    # Compare Pade approximation to true result
+    p = np.array([float(p0) for p0 in p])
+    q = np.array([float(q0) for q0 in q])
+    pade_approx = np.polyval(p, z)/np.polyval(q, z)
+    pade_err = abs(pade_approx - lambertw_std)
+    axes[0].pcolormesh(x, y, pade_err)
+    # Compare two terms of asymptotic series to true result
+    asy_approx = np.log(z) - np.log(np.log(z))
+    asy_err = abs(asy_approx - lambertw_std)
+    axes[1].pcolormesh(x, y, asy_err)
+    # Compare two terms of the series around the branch point to the
+    # true result
+    p = np.sqrt(2*(np.exp(1)*z + 1))
+    series_approx = -1 + p - p**2/3
+    series_err = abs(series_approx - lambertw_std)
+    im = axes[2].pcolormesh(x, y, series_err)
+
+    fig.colorbar(im, ax=axes.ravel().tolist())
+    plt.show()
+
+    fig, ax = plt.subplots(nrows=1, ncols=1)
+    pade_better = pade_err < asy_err
+    im = ax.pcolormesh(x, y, pade_better)
+    t = np.linspace(-0.3, 0.3)
+    ax.plot(-2.5*abs(t) - 0.2, t, 'r')
+    fig.colorbar(im, ax=ax)
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()

v12x/pylib/scipy/special/_precompute/loggamma.py

@@ -0,0 +1,43 @@
+"""Precompute series coefficients for log-Gamma."""
+
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+def stirling_series(N):
+    with mpmath.workdps(100):
+        coeffs = [mpmath.bernoulli(2*n)/(2*n*(2*n - 1))
+                  for n in range(1, N + 1)]
+    return coeffs
+
+
+def taylor_series_at_1(N):
+    coeffs = []
+    with mpmath.workdps(100):
+        coeffs.append(-mpmath.euler)
+        for n in range(2, N + 1):
+            coeffs.append((-1)**n*mpmath.zeta(n)/n)
+    return coeffs
+
+
+def main():
+    print(__doc__)
+    print()
+    stirling_coeffs = [mpmath.nstr(x, 20, min_fixed=0, max_fixed=0)
+                       for x in stirling_series(8)[::-1]]
+    taylor_coeffs = [mpmath.nstr(x, 20, min_fixed=0, max_fixed=0)
+                     for x in taylor_series_at_1(23)[::-1]]
+    print("Stirling series coefficients")
+    print("----------------------------")
+    print("\n".join(stirling_coeffs))
+    print()
+    print("Taylor series coefficients")
+    print("--------------------------")
+    print("\n".join(taylor_coeffs))
+    print()
+
+
+if __name__ == '__main__':
+    main()

v12x/pylib/scipy/special/_precompute/struve_convergence.py

@@ -0,0 +1,131 @@
+"""
+Convergence regions of the expansions used in ``struve.c``
+
+Note that for v >> z both functions tend rapidly to 0,
+and for v << -z, they tend to infinity.
+
+The floating-point functions over/underflow in the lower left and right
+corners of the figure.
+
+
+Figure legend
+=============
+
+Red region
+    Power series is close (1e-12) to the mpmath result
+
+Blue region
+    Asymptotic series is close to the mpmath result
+
+Green region
+    Bessel series is close to the mpmath result
+
+Dotted colored lines
+    Boundaries of the regions
+
+Solid colored lines
+    Boundaries estimated by the routine itself. These will be used
+    for determining which of the results to use.
+
+Black dashed line
+    The line z = 0.7*|v| + 12
+
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+import mpmath
+
+
+def err_metric(a, b, atol=1e-290):
+    m = abs(a - b) / (atol + abs(b))
+    m[np.isinf(b) & (a == b)] = 0
+    return m
+
+
+def do_plot(is_h=True):
+    from scipy.special._ufuncs import (_struve_power_series,
+                                       _struve_asymp_large_z,
+                                       _struve_bessel_series)
+
+    vs = np.linspace(-1000, 1000, 91)
+    zs = np.sort(np.r_[1e-5, 1.0, np.linspace(0, 700, 91)[1:]])
+
+    rp = _struve_power_series(vs[:,None], zs[None,:], is_h)
+    ra = _struve_asymp_large_z(vs[:,None], zs[None,:], is_h)
+    rb = _struve_bessel_series(vs[:,None], zs[None,:], is_h)
+
+    mpmath.mp.dps = 50
+    if is_h:
+        def sh(v, z):
+            return float(mpmath.struveh(mpmath.mpf(v), mpmath.mpf(z)))
+    else:
+        def sh(v, z):
+            return float(mpmath.struvel(mpmath.mpf(v), mpmath.mpf(z)))
+    ex = np.vectorize(sh, otypes='d')(vs[:,None], zs[None,:])
+
+    err_a = err_metric(ra[0], ex) + 1e-300
+    err_p = err_metric(rp[0], ex) + 1e-300
+    err_b = err_metric(rb[0], ex) + 1e-300
+
+    err_est_a = abs(ra[1]/ra[0])
+    err_est_p = abs(rp[1]/rp[0])
+    err_est_b = abs(rb[1]/rb[0])
+
+    z_cutoff = 0.7*abs(vs) + 12
+
+    levels = [-1000, -12]
+
+    plt.cla()
+
+    plt.hold(1)
+    plt.contourf(vs, zs, np.log10(err_p).T,
+                 levels=levels, colors=['r', 'r'], alpha=0.1)
+    plt.contourf(vs, zs, np.log10(err_a).T,
+                 levels=levels, colors=['b', 'b'], alpha=0.1)
+    plt.contourf(vs, zs, np.log10(err_b).T,
+                 levels=levels, colors=['g', 'g'], alpha=0.1)
+
+    plt.contour(vs, zs, np.log10(err_p).T,
+                levels=levels, colors=['r', 'r'], linestyles=[':', ':'])
+    plt.contour(vs, zs, np.log10(err_a).T,
+                levels=levels, colors=['b', 'b'], linestyles=[':', ':'])
+    plt.contour(vs, zs, np.log10(err_b).T,
+                levels=levels, colors=['g', 'g'], linestyles=[':', ':'])
+
+    lp = plt.contour(vs, zs, np.log10(err_est_p).T,
+                     levels=levels, colors=['r', 'r'], linestyles=['-', '-'])
+    la = plt.contour(vs, zs, np.log10(err_est_a).T,
+                     levels=levels, colors=['b', 'b'], linestyles=['-', '-'])
+    lb = plt.contour(vs, zs, np.log10(err_est_b).T,
+                     levels=levels, colors=['g', 'g'], linestyles=['-', '-'])
+
+    plt.clabel(lp, fmt={-1000: 'P', -12: 'P'})
+    plt.clabel(la, fmt={-1000: 'A', -12: 'A'})
+    plt.clabel(lb, fmt={-1000: 'B', -12: 'B'})
+
+    plt.plot(vs, z_cutoff, 'k--')
+
+    plt.xlim(vs.min(), vs.max())
+    plt.ylim(zs.min(), zs.max())
+
+    plt.xlabel('v')
+    plt.ylabel('z')
+
+
+def main():
+    plt.clf()
+    plt.subplot(121)
+    do_plot(True)
+    plt.title('Struve H')
+
+    plt.subplot(122)
+    do_plot(False)
+    plt.title('Struve L')
+
+    plt.savefig('struve_convergence.png')
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

v12x/pylib/scipy/special/_precompute/utils.py

@@ -0,0 +1,38 @@
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+try:
+    from sympy.abc import x
+except ImportError:
+    pass
+
+
+def lagrange_inversion(a):
+    """Given a series
+
+    f(x) = a[1]*x + a[2]*x**2 + ... + a[n-1]*x**(n - 1),
+
+    use the Lagrange inversion formula to compute a series
+
+    g(x) = b[1]*x + b[2]*x**2 + ... + b[n-1]*x**(n - 1)
+
+    so that f(g(x)) = g(f(x)) = x mod x**n. We must have a[0] = 0, so
+    necessarily b[0] = 0 too.
+
+    The algorithm is naive and could be improved, but speed isn't an
+    issue here and it's easy to read.
+
+    """
+    n = len(a)
+    f = sum(a[i]*x**i for i in range(n))
+    h = (x/f).series(x, 0, n).removeO()
+    hpower = [h**0]
+    for k in range(n):
+        hpower.append((hpower[-1]*h).expand())
+    b = [mp.mpf(0)]
+    for k in range(1, n):
+        b.append(hpower[k].coeff(x, k - 1)/k)
+    b = [mp.mpf(x) for x in b]
+    return b

v12x/pylib/scipy/special/_precompute/wright_bessel.py

@@ -0,0 +1,342 @@
+"""Precompute coefficients of several series expansions
+of Wright's generalized Bessel function Phi(a, b, x).
+
+See https://dlmf.nist.gov/10.46.E1 with rho=a, beta=b, z=x.
+"""
+from argparse import ArgumentParser, RawTextHelpFormatter
+import numpy as np
+from scipy.integrate import quad
+from scipy.optimize import minimize_scalar, curve_fit
+from time import time
+
+try:
+    import sympy
+    from sympy import EulerGamma, Rational, S, Sum, \
+        factorial, gamma, gammasimp, pi, polygamma, symbols, zeta
+    from sympy.polys.polyfuncs import horner
+except ImportError:
+    pass
+
+
+def series_small_a():
+    """Tylor series expansion of Phi(a, b, x) in a=0 up to order 5.
+    """
+    order = 5
+    a, b, x, k = symbols("a b x k")
+    A = []  # terms with a
+    X = []  # terms with x
+    B = []  # terms with b (polygammas)
+    # Phi(a, b, x) = exp(x)/gamma(b) * sum(A[i] * X[i] * B[i])
+    expression = Sum(x**k/factorial(k)/gamma(a*k+b), (k, 0, S.Infinity))
+    expression = gamma(b)/sympy.exp(x) * expression
+
+    # nth term of taylor series in a=0: a^n/n! * (d^n Phi(a, b, x)/da^n at a=0)
+    for n in range(0, order+1):
+        term = expression.diff(a, n).subs(a, 0).simplify().doit()
+        # set the whole bracket involving polygammas to 1
+        x_part = (term.subs(polygamma(0, b), 1)
+                  .replace(polygamma, lambda *args: 0))
+        # sign convention: x part always positive
+        x_part *= (-1)**n
+
+        A.append(a**n/factorial(n))
+        X.append(horner(x_part))
+        B.append(horner((term/x_part).simplify()))
+
+    s = "Tylor series expansion of Phi(a, b, x) in a=0 up to order 5.\n"
+    s += "Phi(a, b, x) = exp(x)/gamma(b) * sum(A[i] * X[i] * B[i], i=0..5)\n"
+    for name, c in zip(['A', 'X', 'B'], [A, X, B]):
+        for i in range(len(c)):
+            s += f"\n{name}[{i}] = " + str(c[i])
+    return s
+
+
+# expansion of digamma
+def dg_series(z, n):
+    """Symbolic expansion of digamma(z) in z=0 to order n.
+
+    See https://dlmf.nist.gov/5.7.E4 and with https://dlmf.nist.gov/5.5.E2
+    """
+    k = symbols("k")
+    return -1/z - EulerGamma + \
+        sympy.summation((-1)**k * zeta(k) * z**(k-1), (k, 2, n+1))
+
+
+def pg_series(k, z, n):
+    """Symbolic expansion of polygamma(k, z) in z=0 to order n."""
+    return sympy.diff(dg_series(z, n+k), z, k)
+
+
+def series_small_a_small_b():
+    """Tylor series expansion of Phi(a, b, x) in a=0 and b=0 up to order 5.
+
+    Be aware of cancellation of poles in b=0 of digamma(b)/Gamma(b) and
+    polygamma functions.
+
+    digamma(b)/Gamma(b) = -1 - 2*M_EG*b + O(b^2)
+    digamma(b)^2/Gamma(b) = 1/b + 3*M_EG + b*(-5/12*PI^2+7/2*M_EG^2) + O(b^2)
+    polygamma(1, b)/Gamma(b) = 1/b + M_EG + b*(1/12*PI^2 + 1/2*M_EG^2) + O(b^2)
+    and so on.
+    """
+    order = 5
+    a, b, x, k = symbols("a b x k")
+    M_PI, M_EG, M_Z3 = symbols("M_PI M_EG M_Z3")
+    c_subs = {pi: M_PI, EulerGamma: M_EG, zeta(3): M_Z3}
+    A = []  # terms with a
+    X = []  # terms with x
+    B = []  # terms with b (polygammas expanded)
+    C = []  # terms that generate B
+    # Phi(a, b, x) = exp(x) * sum(A[i] * X[i] * B[i])
+    # B[0] = 1
+    # B[k] = sum(C[k] * b**k/k!, k=0..)
+    # Note: C[k] can be obtained from a series expansion of 1/gamma(b).
+    expression = gamma(b)/sympy.exp(x) * \
+        Sum(x**k/factorial(k)/gamma(a*k+b), (k, 0, S.Infinity))
+
+    # nth term of taylor series in a=0: a^n/n! * (d^n Phi(a, b, x)/da^n at a=0)
+    for n in range(0, order+1):
+        term = expression.diff(a, n).subs(a, 0).simplify().doit()
+        # set the whole bracket involving polygammas to 1
+        x_part = (term.subs(polygamma(0, b), 1)
+                  .replace(polygamma, lambda *args: 0))
+        # sign convention: x part always positive
+        x_part *= (-1)**n
+        # expansion of polygamma part with 1/gamma(b)
+        pg_part = term/x_part/gamma(b)
+        if n >= 1:
+            # Note: highest term is digamma^n
+            pg_part = pg_part.replace(polygamma,
+                                      lambda k, x: pg_series(k, x, order+1+n))
+            pg_part = (pg_part.series(b, 0, n=order+1-n)
+                       .removeO()
+                       .subs(polygamma(2, 1), -2*zeta(3))
+                       .simplify()
+                       )
+
+        A.append(a**n/factorial(n))
+        X.append(horner(x_part))
+        B.append(pg_part)
+
+    # Calculate C and put in the k!
+    C = sympy.Poly(B[1].subs(c_subs), b).coeffs()
+    C.reverse()
+    for i in range(len(C)):
+        C[i] = (C[i] * factorial(i)).simplify()
+
+    s = "Tylor series expansion of Phi(a, b, x) in a=0 and b=0 up to order 5."
+    s += "\nPhi(a, b, x) = exp(x) * sum(A[i] * X[i] * B[i], i=0..5)\n"
+    s += "B[0] = 1\n"
+    s += "B[i] = sum(C[k+i-1] * b**k/k!, k=0..)\n"
+    s += "\nM_PI = pi"
+    s += "\nM_EG = EulerGamma"
+    s += "\nM_Z3 = zeta(3)"
+    for name, c in zip(['A', 'X'], [A, X]):
+        for i in range(len(c)):
+            s += f"\n{name}[{i}] = "
+            s += str(c[i])
+    # For C, do also compute the values numerically
+    for i in range(len(C)):
+        s += f"\n# C[{i}] = "
+        s += str(C[i])
+        s += f"\nC[{i}] = "
+        s += str(C[i].subs({M_EG: EulerGamma, M_PI: pi, M_Z3: zeta(3)})
+                 .evalf(17))
+
+    # Does B have the assumed structure?
+    s += "\n\nTest if B[i] does have the assumed structure."
+    s += "\nC[i] are derived from B[1] alone."
+    s += "\nTest B[2] == C[1] + b*C[2] + b^2/2*C[3] + b^3/6*C[4] + .."
+    test = sum([b**k/factorial(k) * C[k+1] for k in range(order-1)])
+    test = (test - B[2].subs(c_subs)).simplify()
+    s += f"\ntest successful = {test==S(0)}"
+    s += "\nTest B[3] == C[2] + b*C[3] + b^2/2*C[4] + .."
+    test = sum([b**k/factorial(k) * C[k+2] for k in range(order-2)])
+    test = (test - B[3].subs(c_subs)).simplify()
+    s += f"\ntest successful = {test==S(0)}"
+    return s
+
+
+def asymptotic_series():
+    """Asymptotic expansion for large x.
+
+    Phi(a, b, x) ~ Z^(1/2-b) * exp((1+a)/a * Z) * sum_k (-1)^k * C_k / Z^k
+    Z = (a*x)^(1/(1+a))
+
+    Wright (1935) lists the coefficients C_0 and C_1 (he calls them a_0 and
+    a_1). With slightly different notation, Paris (2017) lists coefficients
+    c_k up to order k=3.
+    Paris (2017) uses ZP = (1+a)/a * Z  (ZP = Z of Paris) and
+    C_k = C_0 * (-a/(1+a))^k * c_k
+    """
+    order = 8
+
+    class g(sympy.Function):
+        """Helper function g according to Wright (1935)
+
+        g(n, rho, v) = (1 + (rho+2)/3 * v + (rho+2)*(rho+3)/(2*3) * v^2 + ...)
+
+        Note: Wright (1935) uses square root of above definition.
+        """
+        nargs = 3
+
+        @classmethod
+        def eval(cls, n, rho, v):
+            if not n >= 0:
+                raise ValueError("must have n >= 0")
+            elif n == 0:
+                return 1
+            else:
+                return g(n-1, rho, v) \
+                    + gammasimp(gamma(rho+2+n)/gamma(rho+2)) \
+                    / gammasimp(gamma(3+n)/gamma(3))*v**n
+
+    class coef_C(sympy.Function):
+        """Calculate coefficients C_m for integer m.
+
+        C_m is the coefficient of v^(2*m) in the Taylor expansion in v=0 of
+        Gamma(m+1/2)/(2*pi) * (2/(rho+1))^(m+1/2) * (1-v)^(-b)
+            * g(rho, v)^(-m-1/2)
+        """
+        nargs = 3
+
+        @classmethod
+        def eval(cls, m, rho, beta):
+            if not m >= 0:
+                raise ValueError("must have m >= 0")
+
+            v = symbols("v")
+            expression = (1-v)**(-beta) * g(2*m, rho, v)**(-m-Rational(1, 2))
+            res = expression.diff(v, 2*m).subs(v, 0) / factorial(2*m)
+            res = res * (gamma(m + Rational(1, 2)) / (2*pi)
+                         * (2/(rho+1))**(m + Rational(1, 2)))
+            return res
+
+    # in order to have nice ordering/sorting of expressions, we set a = xa.
+    xa, b, xap1 = symbols("xa b xap1")
+    C0 = coef_C(0, xa, b)
+    # a1 = a(1, rho, beta)
+    s = "Asymptotic expansion for large x\n"
+    s += "Phi(a, b, x) = Z**(1/2-b) * exp((1+a)/a * Z) \n"
+    s += "               * sum((-1)**k * C[k]/Z**k, k=0..6)\n\n"
+    s += "Z      = pow(a * x, 1/(1+a))\n"
+    s += "A[k]   = pow(a, k)\n"
+    s += "B[k]   = pow(b, k)\n"
+    s += "Ap1[k] = pow(1+a, k)\n\n"
+    s += "C[0] = 1./sqrt(2. * M_PI * Ap1[1])\n"
+    for i in range(1, order+1):
+        expr = (coef_C(i, xa, b) / (C0/(1+xa)**i)).simplify()
+        factor = [x.denominator() for x in sympy.Poly(expr).coeffs()]
+        factor = sympy.lcm(factor)
+        expr = (expr * factor).simplify().collect(b, sympy.factor)
+        expr = expr.xreplace({xa+1: xap1})
+        s += f"C[{i}] = C[0] / ({factor} * Ap1[{i}])\n"
+        s += f"C[{i}] *= {str(expr)}\n\n"
+    import re
+    re_a = re.compile(r'xa\*\*(\d+)')
+    s = re_a.sub(r'A[\1]', s)
+    re_b = re.compile(r'b\*\*(\d+)')
+    s = re_b.sub(r'B[\1]', s)
+    s = s.replace('xap1', 'Ap1[1]')
+    s = s.replace('xa', 'a')
+    # max integer = 2^31-1 = 2,147,483,647. Solution: Put a point after 10
+    # or more digits.
+    re_digits = re.compile(r'(\d{10,})')
+    s = re_digits.sub(r'\1.', s)
+    return s
+
+
+def optimal_epsilon_integral():
+    """Fit optimal choice of epsilon for integral representation.
+
+    The integrand of
+        int_0^pi P(eps, a, b, x, phi) * dphi
+    can exhibit oscillatory behaviour. It stems from the cosine of P and can be
+    minimized by minimizing the arc length of the argument
+        f(phi) = eps * sin(phi) - x * eps^(-a) * sin(a * phi) + (1 - b) * phi
+    of cos(f(phi)).
+    We minimize the arc length in eps for a grid of values (a, b, x) and fit a
+    parametric function to it.
+    """
+    def fp(eps, a, b, x, phi):
+        """Derivative of f w.r.t. phi."""
+        eps_a = np.power(1. * eps, -a)
+        return eps * np.cos(phi) - a * x * eps_a * np.cos(a * phi) + 1 - b
+
+    def arclength(eps, a, b, x, epsrel=1e-2, limit=100):
+        """Compute Arc length of f.
+
+        Note that the arc length of a function f from t0 to t1 is given by
+            int_t0^t1 sqrt(1 + f'(t)^2) dt
+        """
+        return quad(lambda phi: np.sqrt(1 + fp(eps, a, b, x, phi)**2),
+                    0, np.pi,
+                    epsrel=epsrel, limit=100)[0]
+
+    # grid of minimal arc length values
+    data_a = [1e-3, 0.1, 0.5, 0.9, 1, 2, 4, 5, 6, 8]
+    data_b = [0, 1, 4, 7, 10]
+    data_x = [1, 1.5, 2, 4, 10, 20, 50, 100, 200, 500, 1e3, 5e3, 1e4]
+    data_a, data_b, data_x = np.meshgrid(data_a, data_b, data_x)
+    data_a, data_b, data_x = (data_a.flatten(), data_b.flatten(),
+                              data_x.flatten())
+    best_eps = []
+    for i in range(data_x.size):
+        best_eps.append(
+            minimize_scalar(lambda eps: arclength(eps, data_a[i], data_b[i],
+                                                  data_x[i]),
+                            bounds=(1e-3, 1000),
+                            method='Bounded', options={'xatol': 1e-3}).x
+        )
+    best_eps = np.array(best_eps)
+    # pandas would be nice, but here a dictionary is enough
+    df = {'a': data_a,
+          'b': data_b,
+          'x': data_x,
+          'eps': best_eps,
+          }
+
+    def func(data, A0, A1, A2, A3, A4, A5):
+        """Compute parametric function to fit."""
+        a = data['a']
+        b = data['b']
+        x = data['x']
+        return (A0 * b * np.exp(-0.5 * a)
+                + np.exp(A1 + 1 / (1 + a) * np.log(x) - A2 * np.exp(-A3 * a)
+                         + A4 / (1 + np.exp(A5 * a))))
+
+    func_params = list(curve_fit(func, df, df['eps'], method='trf')[0])
+
+    s = "Fit optimal eps for integrand P via minimal arc length\n"
+    s += "with parametric function:\n"
+    s += "optimal_eps = (A0 * b * exp(-a/2) + exp(A1 + 1 / (1 + a) * log(x)\n"
+    s += "              - A2 * exp(-A3 * a) + A4 / (1 + exp(A5 * a)))\n\n"
+    s += "Fitted parameters A0 to A5 are:\n"
+    s += ', '.join([f'{x:.5g}' for x in func_params])
+    return s
+
+
+def main():
+    t0 = time()
+    parser = ArgumentParser(description=__doc__,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('action', type=int, choices=[1, 2, 3, 4],
+                        help='chose what expansion to precompute\n'
+                             '1 : Series for small a\n'
+                             '2 : Series for small a and small b\n'
+                             '3 : Asymptotic series for large x\n'
+                             '    This may take some time (>4h).\n'
+                             '4 : Fit optimal eps for integral representation.'
+                        )
+    args = parser.parse_args()
+
+    switch = {1: lambda: print(series_small_a()),
+              2: lambda: print(series_small_a_small_b()),
+              3: lambda: print(asymptotic_series()),
+              4: lambda: print(optimal_epsilon_integral())
+              }
+    switch.get(args.action, lambda: print("Invalid input."))()
+    print(f"\n{(time() - t0)/60:.1f} minutes elapsed.\n")
+
+
+if __name__ == '__main__':
+    main()

v12x/pylib/scipy/special/_precompute/wright_bessel_data.py

@@ -0,0 +1,152 @@
+"""Compute a grid of values for Wright's generalized Bessel function
+and save the values to data files for use in tests. Using mpmath directly in
+tests would take too long.
+
+This takes about 10 minutes to run on a 2.7 GHz i7 Macbook Pro.
+"""
+from functools import lru_cache
+import os
+from time import time
+
+import numpy as np
+from scipy.special._mptestutils import mpf2float
+
+try:
+    import mpmath as mp
+except ImportError:
+    pass
+
+# exp_inf: smallest value x for which exp(x) == inf
+exp_inf = 709.78271289338403
+
+
+# 64 Byte per value
+@lru_cache(maxsize=100_000)
+def rgamma_cached(x, dps):
+    with mp.workdps(dps):
+        return mp.rgamma(x)
+
+
+def mp_wright_bessel(a, b, x, dps=50, maxterms=2000):
+    """Compute Wright's generalized Bessel function as Series with mpmath.
+    """
+    with mp.workdps(dps):
+        a, b, x = mp.mpf(a), mp.mpf(b), mp.mpf(x)
+        res = mp.nsum(lambda k: x**k / mp.fac(k)
+                      * rgamma_cached(a * k + b, dps=dps),
+                      [0, mp.inf],
+                      tol=dps, method='s', steps=[maxterms]
+                      )
+        return mpf2float(res)
+
+
+def main():
+    t0 = time()
+    print(__doc__)
+    pwd = os.path.dirname(__file__)
+    eps = np.finfo(float).eps * 100
+
+    a_range = np.array([eps,
+                        1e-4 * (1 - eps), 1e-4, 1e-4 * (1 + eps),
+                        1e-3 * (1 - eps), 1e-3, 1e-3 * (1 + eps),
+                        0.1, 0.5,
+                        1 * (1 - eps), 1, 1 * (1 + eps),
+                        1.5, 2, 4.999, 5, 10])
+    b_range = np.array([0, eps, 1e-10, 1e-5, 0.1, 1, 2, 10, 20, 100])
+    x_range = np.array([0, eps, 1 - eps, 1, 1 + eps,
+                        1.5,
+                        2 - eps, 2, 2 + eps,
+                        9 - eps, 9, 9 + eps,
+                        10 * (1 - eps), 10, 10 * (1 + eps),
+                        100 * (1 - eps), 100, 100 * (1 + eps),
+                        500, exp_inf, 1e3, 1e5, 1e10, 1e20])
+
+    a_range, b_range, x_range = np.meshgrid(a_range, b_range, x_range,
+                                            indexing='ij')
+    a_range = a_range.flatten()
+    b_range = b_range.flatten()
+    x_range = x_range.flatten()
+
+    # filter out some values, especially too large x
+    bool_filter = ~((a_range < 5e-3) & (x_range >= exp_inf))
+    bool_filter = bool_filter & ~((a_range < 0.2) & (x_range > exp_inf))
+    bool_filter = bool_filter & ~((a_range < 0.5) & (x_range > 1e3))
+    bool_filter = bool_filter & ~((a_range < 0.56) & (x_range > 5e3))
+    bool_filter = bool_filter & ~((a_range < 1) & (x_range > 1e4))
+    bool_filter = bool_filter & ~((a_range < 1.4) & (x_range > 1e5))
+    bool_filter = bool_filter & ~((a_range < 1.8) & (x_range > 1e6))
+    bool_filter = bool_filter & ~((a_range < 2.2) & (x_range > 1e7))
+    bool_filter = bool_filter & ~((a_range < 2.5) & (x_range > 1e8))
+    bool_filter = bool_filter & ~((a_range < 2.9) & (x_range > 1e9))
+    bool_filter = bool_filter & ~((a_range < 3.3) & (x_range > 1e10))
+    bool_filter = bool_filter & ~((a_range < 3.7) & (x_range > 1e11))
+    bool_filter = bool_filter & ~((a_range < 4) & (x_range > 1e12))
+    bool_filter = bool_filter & ~((a_range < 4.4) & (x_range > 1e13))
+    bool_filter = bool_filter & ~((a_range < 4.7) & (x_range > 1e14))
+    bool_filter = bool_filter & ~((a_range < 5.1) & (x_range > 1e15))
+    bool_filter = bool_filter & ~((a_range < 5.4) & (x_range > 1e16))
+    bool_filter = bool_filter & ~((a_range < 5.8) & (x_range > 1e17))
+    bool_filter = bool_filter & ~((a_range < 6.2) & (x_range > 1e18))
+    bool_filter = bool_filter & ~((a_range < 6.2) & (x_range > 1e18))
+    bool_filter = bool_filter & ~((a_range < 6.5) & (x_range > 1e19))
+    bool_filter = bool_filter & ~((a_range < 6.9) & (x_range > 1e20))
+
+    # filter out known values that do not meet the required numerical accuracy
+    # see test test_wright_data_grid_failures
+    failing = np.array([
+        [0.1, 100, 709.7827128933841],
+        [0.5, 10, 709.7827128933841],
+        [0.5, 10, 1000],
+        [0.5, 100, 1000],
+        [1, 20, 100000],
+        [1, 100, 100000],
+        [1.0000000000000222, 20, 100000],
+        [1.0000000000000222, 100, 100000],
+        [1.5, 0, 500],
+        [1.5, 2.220446049250313e-14, 500],
+        [1.5, 1.e-10, 500],
+        [1.5, 1.e-05, 500],
+        [1.5, 0.1, 500],
+        [1.5, 20, 100000],
+        [1.5, 100, 100000],
+        ]).tolist()
+
+    does_fail = np.full_like(a_range, False, dtype=bool)
+    for i in range(x_range.size):
+        if [a_range[i], b_range[i], x_range[i]] in failing:
+            does_fail[i] = True
+
+    # filter and flatten
+    a_range = a_range[bool_filter]
+    b_range = b_range[bool_filter]
+    x_range = x_range[bool_filter]
+    does_fail = does_fail[bool_filter]
+
+    dataset = []
+    print(f"Computing {x_range.size} single points.")
+    print("Tests will fail for the following data points:")
+    for i in range(x_range.size):
+        a = a_range[i]
+        b = b_range[i]
+        x = x_range[i]
+        # take care of difficult corner cases
+        maxterms = 1000
+        if a < 1e-6 and x >= exp_inf/10:
+            maxterms = 2000
+        f = mp_wright_bessel(a, b, x, maxterms=maxterms)
+        if does_fail[i]:
+            print("failing data point a, b, x, value = "
+                  f"[{a}, {b}, {x}, {f}]")
+        else:
+            dataset.append((a, b, x, f))
+    dataset = np.array(dataset)
+
+    filename = os.path.join(pwd, '..', 'tests', 'data', 'local',
+                            'wright_bessel.txt')
+    np.savetxt(filename, dataset)
+
+    print(f"{(time() - t0)/60:.1f} minutes elapsed")
+
+
+if __name__ == "__main__":
+    main()

v12x/pylib/scipy/special/_precompute/wrightomega.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+def mpmath_wrightomega(x):
+    return mpmath.lambertw(mpmath.exp(x), mpmath.mpf('-0.5'))
+
+
+def wrightomega_series_error(x):
+    series = x
+    desired = mpmath_wrightomega(x)
+    return abs(series - desired) / desired
+
+
+def wrightomega_exp_error(x):
+    exponential_approx = mpmath.exp(x)
+    desired = mpmath_wrightomega(x)
+    return abs(exponential_approx - desired) / desired
+
+
+def main():
+    desired_error = 2 * np.finfo(float).eps
+    print('Series Error')
+    for x in [1e5, 1e10, 1e15, 1e20]:
+        with mpmath.workdps(100):
+            error = wrightomega_series_error(x)
+        print(x, error, error < desired_error)
+
+    print('Exp error')
+    for x in [-10, -25, -50, -100, -200, -400, -700, -740]:
+        with mpmath.workdps(100):
+            error = wrightomega_exp_error(x)
+        print(x, error, error < desired_error)
+
+
+if __name__ == '__main__':
+    main()

v12x/pylib/scipy/special/_precompute/zetac.py

@@ -0,0 +1,27 @@
+"""Compute the Taylor series for zeta(x) - 1 around x = 0."""
+try:
+    import mpmath
+except ImportError:
+    pass
+
+
+def zetac_series(N):
+    coeffs = []
+    with mpmath.workdps(100):
+        coeffs.append(-1.5)
+        for n in range(1, N):
+            coeff = mpmath.diff(mpmath.zeta, 0, n)/mpmath.factorial(n)
+            coeffs.append(coeff)
+    return coeffs
+
+
+def main():
+    print(__doc__)
+    coeffs = zetac_series(10)
+    coeffs = [mpmath.nstr(x, 20, min_fixed=0, max_fixed=0)
+              for x in coeffs]
+    print("\n".join(coeffs[::-1]))
+
+
+if __name__ == '__main__':
+    main()

v12x/pylib/scipy/special/_sf_error.py

@@ -0,0 +1,15 @@
+"""Warnings and Exceptions that can be raised by special functions."""
+import warnings
+
+
+class SpecialFunctionWarning(Warning):
+    """Warning that can be emitted by special functions."""
+    pass
+
+
+warnings.simplefilter("always", category=SpecialFunctionWarning)
+
+
+class SpecialFunctionError(Exception):
+    """Exception that can be raised by special functions."""
+    pass

v12x/pylib/scipy/special/_spfun_stats.py

@@ -0,0 +1,178 @@
+# Last Change: Sat Mar 21 02:00 PM 2009 J
+
+# Copyright (c) 2001, 2002 Enthought, Inc.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   a. Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#   b. Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#   c. Neither the name of the Enthought nor the names of its contributors
+#      may be used to endorse or promote products derived from this software
+#      without specific prior written permission.
+#
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+# DAMAGE.
+
+"""Some more special functions which may be useful for multivariate statistical
+analysis."""
+
+import numpy as np
+
+import scipy.special._gufuncs as _gufuncs
+from scipy.special import gammaln as loggam
+from scipy.special._ufunc_tools import _with_cache_optimization
+
+
+__all__ = ['multigammaln']
+
+
+def multigammaln(a, d):
+    r"""Returns the log of multivariate gamma, also sometimes called the
+    generalized gamma.
+
+    Parameters
+    ----------
+    a : ndarray
+        The multivariate gamma is computed for each item of `a`.
+    d : int
+        The dimension of the space of integration.
+
+    Returns
+    -------
+    res : ndarray
+        The values of the log multivariate gamma at the given points `a`.
+
+    Notes
+    -----
+    The formal definition of the multivariate gamma of dimension d for a real
+    `a` is
+
+    .. math::
+
+        \Gamma_d(a) = \int_{A>0} e^{-tr(A)} |A|^{a - (d+1)/2} dA
+
+    with the condition :math:`a > (d-1)/2`, and :math:`A > 0` being the set of
+    all the positive definite matrices of dimension `d`.  Note that `a` is a
+    scalar: the integrand only is multivariate, the argument is not (the
+    function is defined over a subset of the real set).
+
+    This can be proven to be equal to the much friendlier equation
+
+    .. math::
+
+        \Gamma_d(a) = \pi^{d(d-1)/4} \prod_{i=1}^{d} \Gamma(a - (i-1)/2).
+
+    References
+    ----------
+    R. J. Muirhead, Aspects of multivariate statistical theory (Wiley Series in
+    probability and mathematical statistics).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.special import multigammaln, gammaln
+    >>> a = 23.5
+    >>> d = 10
+    >>> multigammaln(a, d)
+    454.1488605074416
+
+    Verify that the result agrees with the logarithm of the equation
+    shown above:
+
+    >>> d*(d-1)/4*np.log(np.pi) + gammaln(a - 0.5*np.arange(0, d)).sum()
+    454.1488605074416
+    """
+    a = np.asarray(a)
+    # Support for 0d arrays is needed for array_api_strict and dask.
+    d = np.asarray(d)[()]
+    if not np.isscalar(d) or (np.floor(d) != d):
+        raise ValueError("d should be a positive integer (dimension)")
+    if np.any(a <= 0.5 * (d - 1)):
+        raise ValueError(f"condition a ({a}) > 0.5 * (d-1) ({0.5 * (d-1)}) not met")
+
+    res = (d * (d-1) * 0.25) * np.log(np.pi)
+    res += np.sum(loggam([(a - (j - 1.)/2) for j in range(1, d+1)]), axis=0)
+    return res
+
+
+_poisson_binom_pmf_doc = (
+    """Returns pmf of Poisson Binomial distribution.
+
+    Parameters
+    ----------
+    k : array
+        Number of successes at which to evaluate pmf.
+
+    p : array
+        Success probabilities of independent Bernoulli trials.
+
+    Notes
+    -----
+    This is equivalent to a gufunc with signature ``()(i)->()``.
+    The last dimension of `p` contains success probabilities and
+    the preceding dimensions are batch dimensions. The batch
+    dimensions are broadcast against ``k``.
+
+    The output will be C contiguous regardless of the contiguity of
+    `k` and `p`.
+
+    """
+)
+
+
+_poisson_binom_pmf = _with_cache_optimization(
+    name="_poisson_binom_pmf",
+    arg_names=["k", "p"],
+    docstring=_poisson_binom_pmf_doc,
+    ufunc=_gufuncs._poisson_binom_pmf,
+    cache_arg_indices=[1],
+)
+
+
+_poisson_binom_cdf_doc = (
+    """Returns cdf of Poisson Binomial distribution.
+
+    Parameters
+    ----------
+    k : array
+        Number of successes at which to evaluate cdf.
+
+    p : array
+        Success probabilities of independent Bernoulli trials.
+
+    Notes
+    -----
+    This is equivalent to a gufunc with signature ``()(i)->()``.
+    The last dimension of `p` contains success probabilities and
+    the preceding dimensions are batch dimensions. The batch
+    dimensions are broadcast against ``k``.
+
+    The output will be C contiguous regardless of the contiguity of
+    `k` and `p`.
+
+    """
+)
+
+_poisson_binom_cdf = _with_cache_optimization(
+    name="_poisson_binom_cdf",
+    arg_names=["k", "p"],
+    docstring=_poisson_binom_cdf_doc,
+    ufunc=_gufuncs._poisson_binom_cdf,
+    cache_arg_indices=[1],
+)

v12x/pylib/scipy/special/_spherical_bessel.py

@@ -0,0 +1,401 @@
+from functools import wraps
+import scipy._external.array_api_extra as xpx
+import numpy as np
+from ._ufuncs import (_spherical_jn, _spherical_yn, _spherical_in,
+                      _spherical_kn, _spherical_jn_d, _spherical_yn_d,
+                      _spherical_in_d, _spherical_kn_d)
+
+
+def use_reflection(sign_n_even=None, reflection_fun=None):
+    # - If reflection_fun is not specified, reflects negative `z` and multiplies
+    #   output by appropriate sign (indicated by `sign_n_even`).
+    # - If reflection_fun is specified, calls `reflection_fun` instead of `fun`.
+    # See DLMF 10.47(v) https://dlmf.nist.gov/10.47
+    def decorator(fun):
+        def standard_reflection(n, z, derivative):
+            # sign_n_even indicates the sign when the order `n` is even
+            sign = np.where(n % 2 == 0, sign_n_even, -sign_n_even)
+            # By the chain rule, differentiation at `-z` adds a minus sign
+            sign = -sign if derivative else sign
+            # Evaluate at positive z (minus negative z) and adjust the sign
+            return fun(n, -z, derivative) * sign
+
+        @wraps(fun)
+        def wrapper(n, z, derivative=False):
+            z = np.asarray(z)
+
+            if np.issubdtype(z.dtype, np.complexfloating):
+                return fun(n, z, derivative)  # complex dtype just works
+
+            f2 = standard_reflection if reflection_fun is None else reflection_fun
+            return xpx.apply_where(z.real >= 0, (n, z),
+                                   lambda n, z: fun(n, z, derivative),
+                                   lambda n, z: f2(n, z, derivative))[()]
+        return wrapper
+    return decorator
+
+
+@use_reflection(+1)  # See DLMF 10.47(v) https://dlmf.nist.gov/10.47
+def spherical_jn(n, z, derivative=False):
+    r"""Spherical Bessel function of the first kind or its derivative.
+
+    Defined as [1]_,
+
+    .. math:: j_n(z) = \sqrt{\frac{\pi}{2z}} J_{n + 1/2}(z),
+
+    where :math:`J_n` is the Bessel function of the first kind.
+
+    Parameters
+    ----------
+    n : int, array_like
+        Order of the Bessel function (n >= 0).
+    z : complex or float, array_like
+        Argument of the Bessel function.
+    derivative : bool, optional
+        If True, the value of the derivative (rather than the function
+        itself) is returned.
+
+    Returns
+    -------
+    jn : ndarray
+        Value or derivative of spherical Bessel function of the first kind.
+
+    Notes
+    -----
+    For real arguments greater than the order, the function is computed
+    using the ascending recurrence [2]_. For small real or complex
+    arguments, the definitional relation to the cylindrical Bessel function
+    of the first kind is used.
+
+    The derivative is computed using the relations [3]_,
+
+    .. math::
+        j_n'(z) = j_{n-1}(z) - \frac{n + 1}{z} j_n(z).
+
+        j_0'(z) = -j_1(z)
+
+
+    .. versionadded:: 0.18.0
+
+    References
+    ----------
+    .. [1] https://dlmf.nist.gov/10.47.E3
+    .. [2] https://dlmf.nist.gov/10.51.E1
+    .. [3] https://dlmf.nist.gov/10.51.E2
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The spherical Bessel functions of the first kind :math:`j_n` accept
+    both real and complex second argument. They can return a complex type:
+
+    >>> from scipy.special import spherical_jn
+    >>> spherical_jn(0, 3+5j)
+    (-9.878987731663194-8.021894345786002j)
+    >>> type(spherical_jn(0, 3+5j))
+    <class 'numpy.complex128'>
+
+    We can verify the relation for the derivative from the Notes
+    for :math:`n=3` in the interval :math:`[1, 2]`:
+
+    >>> import numpy as np
+    >>> x = np.arange(1.0, 2.0, 0.01)
+    >>> np.allclose(spherical_jn(3, x, True),
+    ...             spherical_jn(2, x) - 4/x * spherical_jn(3, x))
+    True
+
+    The first few :math:`j_n` with real argument:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(0.0, 10.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-0.5, 1.5)
+    >>> ax.set_title(r'Spherical Bessel functions $j_n$')
+    >>> for n in np.arange(0, 4):
+    ...     ax.plot(x, spherical_jn(n, x), label=rf'$j_{n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    n = np.asarray(n, dtype=np.dtype("long"))
+    if derivative:
+        return _spherical_jn_d(n, z)
+    else:
+        return _spherical_jn(n, z)
+
+
+@use_reflection(-1)  # See DLMF 10.47(v) https://dlmf.nist.gov/10.47
+def spherical_yn(n, z, derivative=False):
+    r"""Spherical Bessel function of the second kind or its derivative.
+
+    Defined as [1]_,
+
+    .. math:: y_n(z) = \sqrt{\frac{\pi}{2z}} Y_{n + 1/2}(z),
+
+    where :math:`Y_n` is the Bessel function of the second kind.
+
+    Parameters
+    ----------
+    n : int, array_like
+        Order of the Bessel function (n >= 0).
+    z : complex or float, array_like
+        Argument of the Bessel function.
+    derivative : bool, optional
+        If True, the value of the derivative (rather than the function
+        itself) is returned.
+
+    Returns
+    -------
+    yn : ndarray
+        Value or derivative of spherical Bessel function of the second kind.
+
+    Notes
+    -----
+    For real arguments, the function is computed using the ascending
+    recurrence [2]_.  For complex arguments, the definitional relation to
+    the cylindrical Bessel function of the second kind is used.
+
+    The derivative is computed using the relations [3]_,
+
+    .. math::
+        y_n' = y_{n-1} - \frac{n + 1}{z} y_n.
+
+        y_0' = -y_1
+
+
+    .. versionadded:: 0.18.0
+
+    References
+    ----------
+    .. [1] https://dlmf.nist.gov/10.47.E4
+    .. [2] https://dlmf.nist.gov/10.51.E1
+    .. [3] https://dlmf.nist.gov/10.51.E2
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The spherical Bessel functions of the second kind :math:`y_n` accept
+    both real and complex second argument. They can return a complex type:
+
+    >>> from scipy.special import spherical_yn
+    >>> spherical_yn(0, 3+5j)
+    (8.022343088587197-9.880052589376795j)
+    >>> type(spherical_yn(0, 3+5j))
+    <class 'numpy.complex128'>
+
+    We can verify the relation for the derivative from the Notes
+    for :math:`n=3` in the interval :math:`[1, 2]`:
+
+    >>> import numpy as np
+    >>> x = np.arange(1.0, 2.0, 0.01)
+    >>> np.allclose(spherical_yn(3, x, True),
+    ...             spherical_yn(2, x) - 4/x * spherical_yn(3, x))
+    True
+
+    The first few :math:`y_n` with real argument:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(0.0, 10.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-2.0, 1.0)
+    >>> ax.set_title(r'Spherical Bessel functions $y_n$')
+    >>> for n in np.arange(0, 4):
+    ...     ax.plot(x, spherical_yn(n, x), label=rf'$y_{n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    n = np.asarray(n, dtype=np.dtype("long"))
+    if derivative:
+        return _spherical_yn_d(n, z)
+    else:
+        return _spherical_yn(n, z)
+
+
+@use_reflection(+1)  # See DLMF 10.47(v) https://dlmf.nist.gov/10.47
+def spherical_in(n, z, derivative=False):
+    r"""Modified spherical Bessel function of the first kind or its derivative.
+
+    Defined as [1]_,
+
+    .. math:: i_n(z) = \sqrt{\frac{\pi}{2z}} I_{n + 1/2}(z),
+
+    where :math:`I_n` is the modified Bessel function of the first kind.
+
+    Parameters
+    ----------
+    n : int, array_like
+        Order of the Bessel function (n >= 0).
+    z : complex or float, array_like
+        Argument of the Bessel function.
+    derivative : bool, optional
+        If True, the value of the derivative (rather than the function
+        itself) is returned.
+
+    Returns
+    -------
+    in : ndarray
+        Value or derivative of modified spherical Bessel function of the first kind.
+
+    Notes
+    -----
+    The function is computed using its definitional relation to the
+    modified cylindrical Bessel function of the first kind.
+
+    The derivative is computed using the relations [2]_,
+
+    .. math::
+        i_n' = i_{n-1} - \frac{n + 1}{z} i_n.
+
+        i_1' = i_0
+
+
+    .. versionadded:: 0.18.0
+
+    References
+    ----------
+    .. [1] https://dlmf.nist.gov/10.47.E7
+    .. [2] https://dlmf.nist.gov/10.51.E5
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The modified spherical Bessel functions of the first kind :math:`i_n`
+    accept both real and complex second argument.
+    They can return a complex type:
+
+    >>> from scipy.special import spherical_in
+    >>> spherical_in(0, 3+5j)
+    (-1.1689867793369182-1.2697305267234222j)
+    >>> type(spherical_in(0, 3+5j))
+    <class 'numpy.complex128'>
+
+    We can verify the relation for the derivative from the Notes
+    for :math:`n=3` in the interval :math:`[1, 2]`:
+
+    >>> import numpy as np
+    >>> x = np.arange(1.0, 2.0, 0.01)
+    >>> np.allclose(spherical_in(3, x, True),
+    ...             spherical_in(2, x) - 4/x * spherical_in(3, x))
+    True
+
+    The first few :math:`i_n` with real argument:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(0.0, 6.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(-0.5, 5.0)
+    >>> ax.set_title(r'Modified spherical Bessel functions $i_n$')
+    >>> for n in np.arange(0, 4):
+    ...     ax.plot(x, spherical_in(n, x), label=rf'$i_{n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    n = np.asarray(n, dtype=np.dtype("long"))
+    if derivative:
+        return _spherical_in_d(n, z)
+    else:
+        return _spherical_in(n, z)
+
+
+def spherical_kn_reflection(n, z, derivative=False):
+    # More complex than the other cases, and this will likely be re-implemented
+    # in C++ anyway. Would require multiple function evaluations. Probably about
+    # as fast to just resort to complex math, and much simpler.
+    return spherical_kn(n, z + 0j, derivative=derivative).real
+
+
+@use_reflection(reflection_fun=spherical_kn_reflection)
+def spherical_kn(n, z, derivative=False):
+    r"""Modified spherical Bessel function of the second kind or its derivative.
+
+    Defined as [1]_,
+
+    .. math:: k_n(z) = \sqrt{\frac{\pi}{2z}} K_{n + 1/2}(z),
+
+    where :math:`K_n` is the modified Bessel function of the second kind.
+
+    Parameters
+    ----------
+    n : int, array_like
+        Order of the Bessel function (n >= 0).
+    z : complex or float, array_like
+        Argument of the Bessel function.
+    derivative : bool, optional
+        If True, the value of the derivative (rather than the function
+        itself) is returned.
+
+    Returns
+    -------
+    kn : ndarray
+        Value or derivative of modified spherical Bessel function of the second kind.
+
+    Notes
+    -----
+    The function is computed using its definitional relation to the
+    modified cylindrical Bessel function of the second kind.
+
+    The derivative is computed using the relations [2]_,
+
+    .. math::
+        k_n' = -k_{n-1} - \frac{n + 1}{z} k_n.
+
+        k_0' = -k_1
+
+
+    .. versionadded:: 0.18.0
+
+    References
+    ----------
+    .. [1] https://dlmf.nist.gov/10.47.E9
+    .. [2] https://dlmf.nist.gov/10.51.E5
+    .. [AS] Milton Abramowitz and Irene A. Stegun, eds.
+        Handbook of Mathematical Functions with Formulas,
+        Graphs, and Mathematical Tables. New York: Dover, 1972.
+
+    Examples
+    --------
+    The modified spherical Bessel functions of the second kind :math:`k_n`
+    accept both real and complex second argument.
+    They can return a complex type:
+
+    >>> from scipy.special import spherical_kn
+    >>> spherical_kn(0, 3+5j)
+    (0.012985785614001561+0.003354691603137546j)
+    >>> type(spherical_kn(0, 3+5j))
+    <class 'numpy.complex128'>
+
+    We can verify the relation for the derivative from the Notes
+    for :math:`n=3` in the interval :math:`[1, 2]`:
+
+    >>> import numpy as np
+    >>> x = np.arange(1.0, 2.0, 0.01)
+    >>> np.allclose(spherical_kn(3, x, True),
+    ...             - 4/x * spherical_kn(3, x) - spherical_kn(2, x))
+    True
+
+    The first few :math:`k_n` with real argument:
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(0.0, 4.0, 0.01)
+    >>> fig, ax = plt.subplots()
+    >>> ax.set_ylim(0.0, 5.0)
+    >>> ax.set_title(r'Modified spherical Bessel functions $k_n$')
+    >>> for n in np.arange(0, 4):
+    ...     ax.plot(x, spherical_kn(n, x), label=rf'$k_{n}$')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+
+    """
+    n = np.asarray(n, dtype=np.dtype("long"))
+    if derivative:
+        return _spherical_kn_d(n, z)
+    else:
+        return _spherical_kn(n, z)

v12x/pylib/scipy/special/_support_alternative_backends.py

@@ -0,0 +1,933 @@
+import functools
+import operator
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from types import ModuleType
+
+import numpy as np
+from scipy._lib._array_api import (
+    array_namespace, scipy_namespace_for, is_numpy, is_dask, is_marray, is_jax_array,
+    is_jax, xp_promote, xp_capabilities, SCIPY_ARRAY_API, get_native_namespace_name,
+    is_array_api_obj
+)
+import scipy._external.array_api_extra as xpx
+from . import _basic
+from . import _spfun_stats
+from . import _ufuncs
+
+# mypy: disable-error-code=dict-item
+
+def _special_namespace_for(xp):
+    spx = scipy_namespace_for(xp)
+    return getattr(spx, "special", None)
+
+
+@dataclass
+class _FuncInfo:
+    # NumPy-only function. IT MUST BE ELEMENTWISE.
+    func: Callable
+    # Number of arguments, not counting out=
+    # This is for testing purposes only, due to the fact that
+    # inspect.signature() just returns *args for ufuncs.
+    n_args: int
+    # @xp_capabilities decorator, for the purpose of
+    # documentation and unit testing. Omit to indicate
+    # full support for all backends.
+    xp_capabilities: Callable[[Callable], Callable] | None = None
+    # Generic implementation to fall back on if there is no native dispatch
+    # available. This is a function that accepts (main namespace, scipy namespace)
+    # and returns the final callable, or None if not available.
+    generic_impl: Callable[
+        [ModuleType, ModuleType | None], Callable | None
+    ] | None = None
+    # Handle case where a backend uses an alternative name for a function.
+    # Should map backend names to alternative function names.
+    alt_names_map: dict[str, str] | None = None
+    # Some functions only take integer arrays for some arguments.
+    int_only: tuple[bool, ...] | None = None
+    # For testing purposes, whether tests should only use positive values
+    # for some arguments. If bool and equal to True, restrict to positive
+    # values for all arguments. To restrict only some arguments to positive
+    # values, pass a tuple of bool of the same length as the number of
+    # arguments, the ith entry in the tuple controls positive_only for
+    # the ith argument. To make backend specific choices for positive_only,
+    # pass in a dict mapping backend names to bool or tuple[bool, ...].
+    positive_only: (
+        bool | tuple[bool, ...] | Mapping[str, bool | tuple[bool, ...]]
+    ) = False
+    # Some special functions are not ufuncs and ufunc-specific tests
+    # should not be applied to these.
+    is_ufunc: bool = True
+    # Some non-ufunc special functions take only Python ints for some arguments.
+    # If so, python_int_only should be a tuple of the same length as the number
+    # of arguments,with value True if the corresponding argument needs to be a
+    # Python int.
+    # Can also take a dict mapping backends to such tuples if an argument being
+    # Python int only is backend specific.
+    python_int_only: dict[str, tuple[bool, ...]] | tuple[bool, ...] | None = None
+    # Some functions which seem to be scalar also accept 0d arrays.
+    scalar_or_0d_only: dict[str, tuple[bool, ...]] | tuple[bool, ...] | None = None
+    # Some functions may not work well with very large integer valued arguments.
+    test_large_ints: bool = True
+    # Some non-ufunc special functions don't decay 0d arrays to scalar.
+    produces_0d: bool = False
+    # Whether or not uses native PyTorch or falls back to NumPy/SciPy. This
+    # is needed because in PyTorch, the default dtype affects promotion
+    # rules when mixing integer and floating dtypes, so relying on a
+    # NumPy/SciPy fallback when the default dtype is other than float64 can lead
+    # to float64 output when native PyTorch would have e.g. float32 output. This
+    # must be accounted for in tests. Not putting this in xp_capabilities for now,
+    # but in the future I think it's likely we may want to add a warning to
+    # xp_capabilities when not using native PyTorch on CPU.
+    torch_native: bool = True
+    # Place a backend in this tuple if `func` is available as `xp.func` but not
+    # available in the `scipy.special` namespace for this backend.
+    # One example is `jax.numpy.sinc` being available but not `jax.scipy.special.sinc`.
+    backends_with_func_in_xp: tuple[str, ...] = ()
+
+    @property
+    def name(self):
+        return self.func.__name__
+
+    # These are needed by @lru_cache below
+    def __hash__(self):
+        return hash(self.func)
+
+    def __eq__(self, other):
+        return isinstance(other, _FuncInfo) and self.func == other.func
+
+    @property
+    def wrapper(self):
+        if self.name in globals():
+            # Already initialised. We are likely in a unit test.
+            # Return function potentially overridden by xpx.testing.lazy_xp_function.
+            import scipy.special
+            return getattr(scipy.special, self.name)
+
+        if SCIPY_ARRAY_API:
+            @functools.wraps(self.func)
+            def wrapped(*args, **kwargs):
+                xp = array_namespace(*args)
+                return self._wrapper_for(xp)(*args, **kwargs)
+
+            # Allow pickling the function. Normally this is done by @wraps,
+            # but in this case it doesn't work because self.func is a ufunc.
+            wrapped.__module__ = "scipy.special"
+            wrapped.__qualname__ = self.name
+            func = wrapped
+        else:
+            func = self.func
+
+        capabilities = self.xp_capabilities or xp_capabilities()
+        # In order to retain a naked ufunc when SCIPY_ARRAY_API is
+        # disabled, xp_capabilities must apply its changes in place.
+        cap_func = capabilities(func)
+        assert cap_func is func
+        return func
+
+    @functools.lru_cache(1000)
+    def _wrapper_for(self, xp):
+        if is_numpy(xp):
+            return self.func
+
+        # If a native implementation is available, use that
+        in_xp = get_native_namespace_name(xp) in self.backends_with_func_in_xp
+        namespace = xp if in_xp else _special_namespace_for(xp)
+        f = _get_native_func(
+            xp, namespace, self.name, alt_names_map=self.alt_names_map
+        )
+        if f is not None:
+            return f
+
+        if in_xp:
+            # when namespace is passed to self.generic_impl below, we want to
+            # make sure that it is the special namespace for xp and not xp
+            # itself, so raise if xp was incorrectly placed in
+            # `backends_with_func_in_xp`.
+            raise RuntimeError(
+                f"func {self.func} is not available as {xp.__name__}.{self.func}"
+                f" but {xp.__name__} was passed in ``in_xp``."
+            )
+
+        # If generic Array API implementation is available, use that
+        if self.generic_impl is not None:
+            f = self.generic_impl(xp, namespace)
+            if f is not None:
+                return f
+
+        if is_marray(xp):
+            # Unwrap the array, apply the function on the wrapped namespace,
+            # and then re-wrap it.
+            # IMPORTANT: this only works because all functions in this module
+            # are elementwise. Otherwise, we would not be able to define a
+            # general rule for mask propagation.
+
+            _f = globals()[self.name]  # Allow nested wrapping
+            def f(*args, _f=_f, xp=xp, **kwargs):
+                data_args = [getattr(arg, 'data', arg) for arg in args]
+                out = _f(*data_args, **kwargs)
+                mask = functools.reduce(operator.or_,
+                                        (getattr(arg, 'mask', False) for arg in args))
+                return xp.asarray(out, mask=mask)
+
+            return f
+
+        if is_dask(xp):
+            # Apply the function to each block of the Dask array.
+            # IMPORTANT: map_blocks works only because all functions in this module
+            # are elementwise. It would be a grave mistake to apply this to gufuncs
+            # or any other function with reductions, as they would change their
+            # output depending on chunking!
+
+            _f = globals()[self.name]  # Allow nested wrapping
+            def f(*args, _f=_f, xp=xp, **kwargs):
+                # Hide dtype kwarg from map_blocks
+                return xp.map_blocks(functools.partial(_f, **kwargs), *args)
+
+            return f
+
+        # As a final resort, use the NumPy/SciPy implementation
+        _f = self.func
+
+        if is_jax(xp) and self.is_ufunc:
+            # if this is a ufunc, we can use the resolve_dtypes method to figure
+            # out what the output dtype should be and use lazy_apply to make this
+            # work with the JAX JIT. Since pure_callback used in lazy_apply will
+            # convert all of the inputs to eager JAX arrays, we will also need to
+            # get the input dtypes inferred from resolve_dtypes so that Python
+            # scalar inputs can be cast to the correct dtype under NEP50 weak
+            # promotion rules rather than getting promoted to the default currently
+            # set in JAX. One cannot just use xp_promote for the input dtypes because
+            # some ufuncs have integer only args.
+            def f(*args, _f=_f, xp=xp, **kwargs):
+                dtypes = (arg.dtype if is_jax_array(arg) else type(arg) for arg in args)
+                # result_dtypes needs an arg for the dtype of the optional out param.
+                # Use `None` since `out` is incompatible with JAX's immutability.
+                dtypes = (*dtypes, None)
+                # JAX uses NumPy dtypes so we can just pass these directly to
+                # resolve_dtypes. TODO: generalize to other lazy backends.
+                dtypes = _f.resolve_dtypes(dtypes)
+                out_dtype = dtypes[-1]
+                args = [
+                    xp.asarray(arg, dtype=dtype)
+                    for arg, dtype in zip(args, dtypes[:-1])
+                ]
+                return xpx.lazy_apply(
+                    _f, *args, xp=xp, as_numpy=True, dtype=out_dtype, **kwargs
+                )
+        else:
+            def f(*args, _f=_f, xp=xp, **kwargs):
+                # Check with `is_array_api_obj` to keep Python scalars untouched so that
+                # NEP50 can be followed.
+                args = [
+                    np.asarray(arg) if is_array_api_obj(arg) else arg for arg in args
+                ]
+                out = _f(*args, **kwargs)
+                return xp.asarray(out)
+
+        return f
+
+
+def _get_native_func(xp, namespace, f_name, *, alt_names_map=None):
+    if alt_names_map is None:
+        alt_names_map = {}
+    f_name = alt_names_map.get(get_native_namespace_name(xp), f_name)
+    f = getattr(namespace, f_name, None)
+    if f is None and hasattr(xp, 'special'):
+        # Currently dead branch, in anticipation of 'special' Array API extension
+        # https://github.com/data-apis/array-api/issues/725
+        f = getattr(xp.special, f_name, None)
+    return f
+
+
+def _rel_entr(xp, spsx):
+    def __rel_entr(x, y, *, xp=xp):
+        # https://github.com/data-apis/array-api-extra/issues/160
+        mxp = array_namespace(x._meta, y._meta) if is_dask(xp) else xp
+        x, y = xp_promote(x, y, broadcast=True, force_floating=True, xp=xp)
+        xy_pos = (x > 0) & (y > 0)
+        xy_inf = xp.isinf(x) & xp.isinf(y)
+        res = xpx.apply_where(
+            xy_pos & ~xy_inf,
+            (x, y),
+            # Note: for very large x, this can overflow.
+            lambda x, y: x * (mxp.log(x) - mxp.log(y)),
+            fill_value=xp.inf
+        )
+        res = xpx.at(res)[(x == 0) & (y >= 0)].set(0)
+        res = xpx.at(res)[xp.isnan(x) | xp.isnan(y) | (xy_pos & xy_inf)].set(xp.nan)
+        return res
+
+    return __rel_entr
+
+
+def _xlogy(xp, spsx):
+    def __xlogy(x, y, *, xp=xp):
+        x, y = xp_promote(x, y, force_floating=True, xp=xp)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            temp = x * xp.log(y)
+        return xp.where(x == 0., 0., temp)
+    return __xlogy
+
+
+
+def _chdtr(xp, spsx):
+    # The difference between this and just using `gammainc`
+    # defined by `get_array_special_func` is that if `gammainc`
+    # isn't found, we don't want to use the SciPy version; we'll
+    # return None here and use the SciPy version of `chdtr`.
+    gammainc = _get_native_func(xp, spsx, 'gammainc')
+    if gammainc is None:
+        return None
+
+    def __chdtr(v, x):
+        res = gammainc(v / 2, x / 2)  # this is almost all we need
+        # The rest can be removed when google/jax#20507 is resolved
+        mask = (v == 0) & (x > 0)  # JAX returns NaN
+        res = xp.where(mask, 1., res)
+        mask = xp.isinf(v) & xp.isinf(x)  # JAX returns 1.0
+        return xp.where(mask, xp.nan, res)
+    return __chdtr
+
+
+def _chdtrc(xp, spsx):
+    # The difference between this and just using `gammaincc`
+    # defined by `get_array_special_func` is that if `gammaincc`
+    # isn't found, we don't want to use the SciPy version; we'll
+    # return None here and use the SciPy version of `chdtrc`.
+    gammaincc = _get_native_func(xp, spsx, 'gammaincc')
+    if gammaincc is None:
+        return None
+
+    def __chdtrc(v, x):
+        res = xp.where(x >= 0, gammaincc(v/2, x/2), 1)
+        i_nan = ((x == 0) & (v == 0)) | xp.isnan(x) | xp.isnan(v) | (v < 0)
+        res = xp.where(i_nan, xp.nan, res)
+        return res
+    return __chdtrc
+
+
+def _betaincc(xp, spsx):
+    betainc = _get_native_func(xp, spsx, 'betainc')
+    if betainc is None:
+        return None
+
+    def __betaincc(a, b, x):
+        # not perfect; might want to just rely on SciPy
+        return betainc(b, a, 1-x)
+    return __betaincc
+
+
+def _stdtr(xp, spsx):
+    betainc = _get_native_func(xp, spsx, 'betainc')
+    if betainc is None:
+        return None
+
+    def __stdtr(df, t):
+        x = df / (t ** 2 + df)
+        tail = betainc(df / 2, 0.5, x) / 2
+        return xp.where(t < 0, tail, 1 - tail)
+
+    return __stdtr
+
+
+def _stdtrit(xp, spsx):
+    # Need either native stdtr or native betainc
+    stdtr = _get_native_func(xp, spsx, 'stdtr') or _stdtr(xp, spsx)
+    # If betainc is not defined, the root-finding would be done with `xp`
+    # despite `stdtr` being evaluated with SciPy/NumPy `stdtr`. Save the
+    # conversions: in this case, just evaluate `stdtrit` with SciPy/NumPy.
+    if stdtr is None:
+        return None
+
+    from scipy.optimize.elementwise import bracket_root, find_root
+
+    def __stdtrit(df, p):
+        def fun(t, df, p):  return stdtr(df, t) - p
+        res_bracket = bracket_root(fun, xp.zeros_like(p), args=(df, p))
+        res_root = find_root(fun, res_bracket.bracket, args=(df, p))
+        return res_root.x
+
+    return __stdtrit
+
+
+# Inventory of automatically dispatched functions
+# IMPORTANT: these must all be **elementwise** functions!
+
+# PyTorch doesn't implement `betainc`.
+# On torch CPU we can fall back to NumPy, but on GPU it won't work.
+_needs_betainc = xp_capabilities(cpu_only=True, exceptions=["jax.numpy", "cupy"])
+
+_special_funcs = (
+    _FuncInfo(
+        _ufuncs.bdtr, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(False, True, False), torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.bdtrc, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(False, True, False), torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.bdtri, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(False, True, False), torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.betainc, 3, _needs_betainc, torch_native=False),
+    _FuncInfo(_ufuncs.betaincc, 3, _needs_betainc, generic_impl=_betaincc,
+              torch_native=False),
+    _FuncInfo(
+        _ufuncs.betaincinv, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        test_large_ints=False, positive_only=True, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.betaln, 2,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        # For betaln, nan mismatches can occur at negative integer a or b of
+        # sufficiently large magnitude.
+        positive_only={"jax.numpy": True}, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.binom, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.boxcox, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.boxcox1p, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.cbrt, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.chdtr, 2, generic_impl=_chdtr),
+    _FuncInfo(_ufuncs.chdtrc, 2, generic_impl=_chdtrc,
+              # scipy/scipy#20972
+              positive_only={"cupy": True, "jax.numpy": True, "torch": True}),
+    _FuncInfo(
+        _ufuncs.chdtri, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.cosdg, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        test_large_ints=False, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.cosm1, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.cotdg, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.ellipk, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.ellipkm1, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.entr, 1),
+    _FuncInfo(_ufuncs.erf, 1),
+    _FuncInfo(_ufuncs.erfc, 1),
+    _FuncInfo(
+        _ufuncs.erfcx, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.erfinv, 1),
+    _FuncInfo(
+        _ufuncs.exp1, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.exp10, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.exp2, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.exprel, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.expi, 1,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.expit, 1),
+    _FuncInfo(
+        _ufuncs.expn, 2,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        # Inconsistent behavior for negative n. expn is not defined here without
+        # taking analytic continuation.
+        positive_only=True,
+        int_only=(True, False), test_large_ints=False,
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.fdtr, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.fdtrc, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.fdtri, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.gamma, 1,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.gammainc, 2),
+    _FuncInfo(
+        _ufuncs.gammaincc, 2,
+        # google/jax#20699
+        positive_only={"jax.numpy": True},
+    ),
+    _FuncInfo(
+        _ufuncs.gammainccinv, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.gammaincinv, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.gammaln, 1),
+    _FuncInfo(
+        _ufuncs.gammasgn, 1,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.gdtr, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.gdtrc, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.huber, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.hyp1f1, 3,
+        xp_capabilities(cpu_only=True, exceptions=["jax.numpy"]),
+        positive_only={"jax.numpy": True}, test_large_ints=False,
+        torch_native=False,
+    ),
+    # Comment out when jax>=0.6.1 is available in Conda for CI.
+    # (or add version requirements to xp_capabilities).
+    # _FuncInfo(
+    #     _ufuncs.hyp2f1, 4,
+    #     xp_capabilities(cpu_only=True, exceptions=["jax.numpy"]),
+    #     positive_only={"jax.numpy": True}, test_large_ints=False,
+    #     torch_native=False,
+    # ),
+    _FuncInfo(
+        _ufuncs.inv_boxcox, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.inv_boxcox1p, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.i0, 1),
+    _FuncInfo(_ufuncs.i0e, 1),
+    _FuncInfo(_ufuncs.i1, 1),
+    _FuncInfo(_ufuncs.i1e, 1),
+    _FuncInfo(
+        _ufuncs.j0, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "bessel_j0"}, test_large_ints=False,
+    ),
+    _FuncInfo(
+        _ufuncs.j1, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "bessel_j1"}, test_large_ints=False,
+    ),
+    _FuncInfo(
+        _ufuncs.k0, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "modified_bessel_k0"},
+    ),
+    _FuncInfo(
+        _ufuncs.k0e, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "scaled_modified_bessel_k0"},
+        test_large_ints=False,
+    ),
+    _FuncInfo(
+        _ufuncs.k1, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "modified_bessel_k1"},
+    ),
+    _FuncInfo(
+        _ufuncs.k1e, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "scaled_modified_bessel_k1"},
+        test_large_ints=False),
+    _FuncInfo(
+        _ufuncs.kl_div, 2,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.log_ndtr, 1),
+    _FuncInfo(
+        _ufuncs.loggamma, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.logit, 1),
+    _FuncInfo(
+        _ufuncs.lpmv, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+        test_large_ints=False,
+    ),
+    _FuncInfo(
+        _spfun_stats.multigammaln, 2,
+        is_ufunc=False,
+        python_int_only={
+            "cupy": (False, True),
+            "jax.numpy": (False, True),
+            "torch": (False, True),
+        },
+        scalar_or_0d_only={
+            "array_api_strict": (False, True),
+            "numpy": (False, True),
+            "dask.array": (False, True),
+            "marray": (False, True),
+        },
+        int_only=(False, True), test_large_ints=False,
+        positive_only=True, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.nbdtr, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(True, True, False), positive_only=True,
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.nbdtrc, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(True, True, False), positive_only=True,
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.nbdtri, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(True, True, False), positive_only=True,
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.ndtr, 1),
+    _FuncInfo(_ufuncs.ndtri, 1),
+    _FuncInfo(
+        _ufuncs.pdtr, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        positive_only=True, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.pdtrc, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        positive_only=True, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.pdtri, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        int_only=(True, False), positive_only=True,
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.poch, 2,
+        xp_capabilities(cpu_only=True, exceptions=["cupy", "jax.numpy"]),
+        test_large_ints=False, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.pseudo_huber, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _basic.polygamma, 2, int_only=(True, False), is_ufunc=False,
+              scalar_or_0d_only={"torch": (True, False)}, produces_0d=True,
+              positive_only={"torch": (True, False), "jax.numpy": True},
+              test_large_ints=False,
+    ),
+    _FuncInfo(_ufuncs.psi, 1, alt_names_map={"jax.numpy": "digamma"}),
+    _FuncInfo(
+        _ufuncs.radian, 3,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.rel_entr, 2, generic_impl=_rel_entr),
+    _FuncInfo(
+        _ufuncs.rgamma, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+    _FuncInfo(
+        _basic.sinc, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        is_ufunc=False,
+        backends_with_func_in_xp=("jax.numpy",),
+    ),
+    _FuncInfo(
+        _ufuncs.sindg, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        test_large_ints=False, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.spence, 1,
+        xp_capabilities(cpu_only=True, exceptions=["jax.numpy"]),
+        torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.stdtr,  2, _needs_betainc, generic_impl=_stdtr,
+              torch_native=False),
+    _FuncInfo(
+        _ufuncs.stdtrit, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],  # needs betainc
+            skip_backends=[("jax.numpy", "no scipy.optimize support")],
+        ),
+        generic_impl=_stdtrit, torch_native=False,
+    ),
+    _FuncInfo(
+        _ufuncs.tandg, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        test_large_ints=False, torch_native=False,
+    ),
+    _FuncInfo(_ufuncs.xlog1py, 2),
+    _FuncInfo(_ufuncs.xlogy, 2, generic_impl=_xlogy),
+    _FuncInfo(
+        _ufuncs.y0, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "bessel_y0"}, test_large_ints=False,
+    ),
+    _FuncInfo(
+        _ufuncs.y1, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy", "torch"],
+            jax_jit=True,
+        ),
+        alt_names_map={"torch": "bessel_y1"}, test_large_ints=False,
+    ),
+    _FuncInfo(
+        _ufuncs.yn, 2,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        positive_only={"cupy": (True, False)}, int_only=(True, False),
+        test_large_ints=False, torch_native=False,
+    ),
+    _FuncInfo(
+        _basic.zeta, 2, is_ufunc=False,
+        positive_only={"jax.numpy": True, "torch": (True, False)},
+        test_large_ints=False,
+    ),
+    _FuncInfo(
+        _ufuncs.zetac, 1,
+        xp_capabilities(
+            cpu_only=True, exceptions=["cupy"],
+            jax_jit=True,
+        ),
+        torch_native=False,
+    ),
+)
+
+# Override ufuncs.
+# When SCIPY_ARRAY_API is disabled, this exclusively updates the docstrings in place
+# and populates the xp_capabilities table, while retaining the original ufuncs.
+globals().update({nfo.func.__name__: nfo.wrapper for nfo in _special_funcs})
+# digamma is an alias for psi. Define here so it also has alternative backend
+# support. Add noqa because the linter gets confused by the sneaky way psi
+# is inserted into globals above.
+digamma = psi  # type:ignore[name-defined]  # noqa: F821
+__all__ = [nfo.func.__name__ for nfo in _special_funcs] + ["digamma"]

v12x/pylib/scipy/special/_testutils.py

@@ -0,0 +1,321 @@
+import os
+import functools
+import operator
+from scipy._external.packaging_version import version
+
+import numpy as np
+from numpy.testing import assert_
+import pytest
+
+import scipy.special as sc
+
+__all__ = ['with_special_errors', 'assert_func_equal', 'FuncData']
+
+
+#------------------------------------------------------------------------------
+# Check if a module is present to be used in tests
+#------------------------------------------------------------------------------
+
+class MissingModule:
+    def __init__(self, name):
+        self.name = name
+
+
+def check_version(module, min_ver):
+    if type(module) is MissingModule:
+        return pytest.mark.skip(reason=f"{module.name} is not installed")
+    return pytest.mark.skipif(
+        version.parse(module.__version__) < version.Version(min_ver),
+        reason=f"{module.__name__} version >= {min_ver} required"
+    )
+
+
+#------------------------------------------------------------------------------
+# Enable convergence and loss of precision warnings -- turn off one by one
+#------------------------------------------------------------------------------
+
+def with_special_errors(func):
+    """
+    Enable special function errors (such as underflow, overflow,
+    loss of precision, etc.)
+    """
+    @functools.wraps(func)
+    def wrapper(*a, **kw):
+        with sc.errstate(all='raise'):
+            res = func(*a, **kw)
+        return res
+    return wrapper
+
+
+#------------------------------------------------------------------------------
+# Comparing function values at many data points at once, with helpful
+# error reports
+#------------------------------------------------------------------------------
+
+def assert_func_equal(func, results, points, rtol=None, atol=None,
+                      param_filter=None, knownfailure=None,
+                      vectorized=True, dtype=None, nan_ok=False,
+                      ignore_inf_sign=False, distinguish_nan_and_inf=True):
+    if hasattr(points, 'next'):
+        # it's a generator
+        points = list(points)
+
+    points = np.asarray(points)
+    if points.ndim == 1:
+        points = points[:,None]
+    nparams = points.shape[1]
+
+    if hasattr(results, '__name__'):
+        # function
+        data = points
+        result_columns = None
+        result_func = results
+    else:
+        # dataset
+        data = np.c_[points, results]
+        result_columns = list(range(nparams, data.shape[1]))
+        result_func = None
+
+    fdata = FuncData(func, data, list(range(nparams)),
+                     result_columns=result_columns, result_func=result_func,
+                     rtol=rtol, atol=atol, param_filter=param_filter,
+                     knownfailure=knownfailure, nan_ok=nan_ok, vectorized=vectorized,
+                     ignore_inf_sign=ignore_inf_sign,
+                     distinguish_nan_and_inf=distinguish_nan_and_inf)
+    fdata.check()
+
+
+class FuncData:
+    """
+    Data set for checking a special function.
+
+    Parameters
+    ----------
+    func : function
+        Function to test
+    data : numpy array
+        columnar data to use for testing
+    param_columns : int or tuple of ints
+        Columns indices in which the parameters to `func` lie.
+        Can be imaginary integers to indicate that the parameter
+        should be cast to complex.
+    result_columns : int or tuple of ints, optional
+        Column indices for expected results from `func`.
+    result_func : callable, optional
+        Function to call to obtain results.
+    rtol : float, optional
+        Required relative tolerance. Default is 5*eps.
+    atol : float, optional
+        Required absolute tolerance. Default is 5*tiny.
+    param_filter : function, or tuple of functions/Nones, optional
+        Filter functions to exclude some parameter ranges.
+        If omitted, no filtering is done.
+    knownfailure : str, optional
+        Known failure error message to raise when the test is run.
+        If omitted, no exception is raised.
+    nan_ok : bool, optional
+        If nan is always an accepted result.
+    vectorized : bool, optional
+        Whether all functions passed in are vectorized.
+    ignore_inf_sign : bool, optional
+        Whether to ignore signs of infinities.
+        (Doesn't matter for complex-valued functions.)
+    distinguish_nan_and_inf : bool, optional
+        If True, treat numbers which contain nans or infs as
+        equal. Sets ignore_inf_sign to be True.
+
+    """
+
+    def __init__(self, func, data, param_columns, result_columns=None,
+                 result_func=None, rtol=None, atol=None, param_filter=None,
+                 knownfailure=None, dataname=None, nan_ok=False, vectorized=True,
+                 ignore_inf_sign=False, distinguish_nan_and_inf=True):
+        self.func = func
+        self.data = data
+        self.dataname = dataname
+        if not hasattr(param_columns, '__len__'):
+            param_columns = (param_columns,)
+        self.param_columns = tuple(param_columns)
+        if result_columns is not None:
+            if not hasattr(result_columns, '__len__'):
+                result_columns = (result_columns,)
+            self.result_columns = tuple(result_columns)
+            if result_func is not None:
+                message = "Only result_func or result_columns should be provided"
+                raise ValueError(message)
+        elif result_func is not None:
+            self.result_columns = None
+        else:
+            raise ValueError("Either result_func or result_columns should be provided")
+        self.result_func = result_func
+        self.rtol = rtol
+        self.atol = atol
+        if not hasattr(param_filter, '__len__'):
+            param_filter = (param_filter,)
+        self.param_filter = param_filter
+        self.knownfailure = knownfailure
+        self.nan_ok = nan_ok
+        self.vectorized = vectorized
+        self.ignore_inf_sign = ignore_inf_sign
+        self.distinguish_nan_and_inf = distinguish_nan_and_inf
+        if not self.distinguish_nan_and_inf:
+            self.ignore_inf_sign = True
+
+    def get_tolerances(self, dtype):
+        if not np.issubdtype(dtype, np.inexact):
+            dtype = np.dtype(float)
+        info = np.finfo(dtype)
+        rtol, atol = self.rtol, self.atol
+        if rtol is None:
+            rtol = 5*info.eps
+        if atol is None:
+            atol = 5*info.tiny
+        return rtol, atol
+
+    def check(self, data=None, dtype=None, dtypes=None):
+        """Check the special function against the data."""
+        __tracebackhide__ = operator.methodcaller(
+            'errisinstance', AssertionError
+        )
+
+        if self.knownfailure:
+            pytest.xfail(reason=self.knownfailure)
+
+        if data is None:
+            data = self.data
+
+        if dtype is None:
+            dtype = data.dtype
+        else:
+            data = data.astype(dtype)
+
+        rtol, atol = self.get_tolerances(dtype)
+
+        # Apply given filter functions
+        if self.param_filter:
+            param_mask = np.ones((data.shape[0],), np.bool_)
+            for j, filter in zip(self.param_columns, self.param_filter):
+                if filter:
+                    param_mask &= list(filter(data[:,j]))
+            data = data[param_mask]
+
+        # Pick parameters from the correct columns
+        params = []
+        for idx, j in enumerate(self.param_columns):
+            if np.iscomplexobj(j):
+                j = int(j.imag)
+                params.append(data[:,j].astype(complex))
+            elif dtypes and idx < len(dtypes):
+                params.append(data[:, j].astype(dtypes[idx]))
+            else:
+                params.append(data[:,j])
+
+        # Helper for evaluating results
+        def eval_func_at_params(func, skip_mask=None):
+            if self.vectorized:
+                got = func(*params)
+            else:
+                got = []
+                for j in range(len(params[0])):
+                    if skip_mask is not None and skip_mask[j]:
+                        got.append(np.nan)
+                        continue
+                    got.append(func(*tuple([params[i][j] for i in range(len(params))])))
+                got = np.asarray(got)
+            if not isinstance(got, tuple):
+                got = (got,)
+            return got
+
+        # Evaluate function to be tested
+        got = eval_func_at_params(self.func)
+
+        # Grab the correct results
+        if self.result_columns is not None:
+            # Correct results passed in with the data
+            wanted = tuple([data[:,icol] for icol in self.result_columns])
+        else:
+            # Function producing correct results passed in
+            skip_mask = None
+            if self.nan_ok and len(got) == 1:
+                # Don't spend time evaluating what doesn't need to be evaluated
+                skip_mask = np.isnan(got[0])
+            wanted = eval_func_at_params(self.result_func, skip_mask=skip_mask)
+
+        # Check the validity of each output returned
+        assert_(len(got) == len(wanted))
+
+        for output_num, (x, y) in enumerate(zip(got, wanted)):
+            if np.issubdtype(x.dtype, np.complexfloating) or self.ignore_inf_sign:
+                pinf_x = np.isinf(x)
+                pinf_y = np.isinf(y)
+                minf_x = np.isinf(x)
+                minf_y = np.isinf(y)
+            else:
+                pinf_x = np.isposinf(x)
+                pinf_y = np.isposinf(y)
+                minf_x = np.isneginf(x)
+                minf_y = np.isneginf(y)
+            nan_x = np.isnan(x)
+            nan_y = np.isnan(y)
+
+            with np.errstate(all='ignore'):
+                abs_y = np.absolute(y)
+                abs_y[~np.isfinite(abs_y)] = 0
+                diff = np.absolute(x - y)
+                diff[~np.isfinite(diff)] = 0
+
+                rdiff = diff / np.absolute(y)
+                rdiff[~np.isfinite(rdiff)] = 0
+
+            tol_mask = (diff <= atol + rtol*abs_y)
+            pinf_mask = (pinf_x == pinf_y)
+            minf_mask = (minf_x == minf_y)
+
+            nan_mask = (nan_x == nan_y)
+
+            bad_j = ~(tol_mask & pinf_mask & minf_mask & nan_mask)
+
+            point_count = bad_j.size
+            if self.nan_ok:
+                bad_j &= ~nan_x
+                bad_j &= ~nan_y
+                point_count -= (nan_x | nan_y).sum()
+
+            if not self.distinguish_nan_and_inf and not self.nan_ok:
+                # If nan's are okay we've already covered all these cases
+                inf_x = np.isinf(x)
+                inf_y = np.isinf(y)
+                both_nonfinite = (inf_x & nan_y) | (nan_x & inf_y)
+                bad_j &= ~both_nonfinite
+                point_count -= both_nonfinite.sum()
+
+            if np.any(bad_j):
+                # Some bad results: inform what, where, and how bad
+                msg = [""]
+                msg.append(f"Max |adiff|: {diff[bad_j].max():g}")
+                msg.append(f"Max |rdiff|: {rdiff[bad_j].max():g}")
+                msg.append(f"Bad results ({np.sum(bad_j)} out of "
+                           f"{point_count}) for the following points "
+                           f"(in output {output_num}):")
+                for j in np.nonzero(bad_j)[0]:
+                    j = int(j)
+                    def fmt(x):
+                        return f'{np.array2string(x[j], precision=18):30s}'
+                    a = "  ".join(map(fmt, params))
+                    b = "  ".join(map(fmt, got))
+                    c = "  ".join(map(fmt, wanted))
+                    d = fmt(rdiff)
+                    msg.append(f"{a} => {b} != {c}  (rdiff {d})")
+                assert_(False, "\n".join(msg))
+
+    def __repr__(self):
+        """Pretty-printing"""
+        if np.any(list(map(np.iscomplexobj, self.param_columns))):
+            is_complex = " (complex)"
+        else:
+            is_complex = ""
+        if self.dataname:
+            return (f"<Data for {self.func.__name__}{is_complex}: "
+                    f"{os.path.basename(self.dataname)}>")
+        else:
+            return f"<Data for {self.func.__name__}{is_complex}>"

v12x/pylib/scipy/special/_ufunc_tools.py

@@ -0,0 +1,162 @@
+"""Helpers for producing efficient wrappers of ufuncs.
+"""
+
+import re
+import numpy as np
+
+
+def _parse_core_ndims(signature):
+    """Return tuple of num core dims per input from gufunc signature."""
+    input_sig = signature.split('->')[0]
+    groups = re.findall(r"\((.*?)\)", input_sig)
+    return tuple(0 if not g.strip() else g.count(',') + 1 for g in groups)
+
+
+def _with_cache_optimization(
+        *,
+        name,
+        arg_names,
+        docstring,
+        ufunc,
+        cache_arg_indices,
+):
+    """Helper to ensure optimal iteration order for ufuncs that use caching.
+
+    This concerns internal caches which are only live over the course of one
+    call to a ufunc to avoid repeated computations during the course of the
+    loops. See the notes below for more information.
+
+    Parameters
+    ----------
+    name : str
+    arg_names : list[str]
+        The function name and arg names are passed in so that the wrapper
+        can be generated with the create name and argument names, improving
+        documentation and autocomplete.
+    docstring : str
+    ufunc : numpy.ufunc
+    cache_arg_indices : list[int]
+       Arguments to ufunc which are used in the kernel to compute an output
+       which is being cached for reuse when iterating over other arguments.
+
+    Returns
+    -------
+    callable
+        A wrapper for ufunc which transposes the axes of the inputs to ensure
+        iteration precedes in such a way to allow the cache within the ufunc
+        kernel to eliminate redundant computation.
+
+    Notes
+    -----
+    There is a common pattern in ufunc kernels exemplified by the situation
+    where some of the arguments are used to compute coeffients of an expansion
+    that is taken over one or more of the other arguments. A classic example is
+    Mathieu functions, which compute coefficients corresponding to the shape
+    parameter q and order m which in principle could be reused for varying
+    values of the parameter x.
+
+    It had long been the case that the expensive computation of coefficients is
+    repeated unnecessarily across values of x. It is possible to add a cache to
+    the ufunc kernel which stores the expansion coefficients and only updates
+    if the pointers into the q and m arrays advance during the course of the
+    ufunc loops. Such a cache is instantiated each time a ufunc is called and
+    only lives during the course of the loops that are carried out for that
+    particular call.
+
+    Whether such a cache actually helps depends on the order in which iteration
+    occurs. Ideally, one would want q and m to advance most slowly and for the
+    iterations over x for fixed q and m to be pushed to the inner most loops.
+    This helper replaces each input array (and a pre-allocated output array)
+    with a view where the axes which should vary most slowly are transposed to
+    the ends and forces computation in C order. This ensures iteration proceeds
+    in the optimal order.
+
+    Note that because the pre-allocated output array used internally is C
+    contiguous, the output will be C contiguous regardless of contiguity of
+    the inputs.
+
+    """
+
+    # Need to keep track of the number of core dimensions for each input
+    # since core dimensions don't participate in broadcasting.
+    core_ndims = (
+        _parse_core_ndims(ufunc.signature)
+        if ufunc.signature is not None
+        else (0,)*ufunc.nin
+    )
+
+    def _wrapper(*args):
+        args = [np.asarray(arg) for arg in args]
+
+        # Fast path for when the arguments which are used in the cached
+        # computation don't have batches.
+        if all(args[i].ndim == core_ndims[i] for i in cache_arg_indices):
+            return ufunc(*args)
+
+        # To get batch_shapes, need to exclude core dimensions. Again, the core
+        # dimensions won't participate in broadcasting.
+        batch_shapes = [
+            arg.shape[:-core_ndims[i]] if core_ndims[i] > 0 else arg.shape
+            for i, arg in enumerate(args)
+        ]
+        batch_shape = np.broadcast_shapes(*batch_shapes)
+        batch_ndim = len(batch_shape)
+
+        # Broadcast each arg so that the batch shapes all agree, but the
+        # core dimensions may still differ.
+        args_b = [
+            np.broadcast_to(arg, batch_shape + arg.shape[-core_ndims[i]:])
+            if core_ndims[i] > 0 else np.broadcast_to(arg, batch_shape)
+            for i, arg in enumerate(args)
+        ]
+
+        # After broadcasting, determine which axes have stride-length
+        # zero for each of the args participating in the cache. The cached
+        # value will remain the same for iterations across these axes.
+        varying_axes = []
+        constant_axes = []
+
+        for ax in range(batch_ndim):
+            is_constant = all(
+                args_b[i].strides[ax] == 0 for i in cache_arg_indices
+            )
+            if is_constant:
+                constant_axes.append(ax)
+            else:
+                varying_axes.append(ax)
+        sorted_batch_axes = varying_axes + constant_axes
+
+        # Push the non-varying axes to the end so that they will vary most
+        # slowly when iterating in C order.
+        args_t = []
+        for i, arg_b in enumerate(args_b):
+            axes = sorted_batch_axes + list(
+                range(batch_ndim, batch_ndim + core_ndims[i])
+            )
+            args_t.append(np.transpose(arg_b, axes=axes))
+
+        # Premake the output array.
+        input_dtypes = tuple(arg.dtype for arg in args_t) + (None,)*ufunc.nout
+        out_dtype = ufunc.resolve_dtypes(input_dtypes)[-1]
+        out_final = np.empty(batch_shape, dtype=out_dtype, order='C')
+        # a view of the output array with axes sorted as needed.
+        out_t = np.transpose(out_final, axes=sorted_batch_axes)
+
+        # Set out to the above view, but return the C contiguous output.
+        # This avoids having non-contiguous output.
+        ufunc(*args_t, out=out_t, order='C')
+        return out_final
+
+    # Do some metaprogramming with exec so that the arg names and func
+    # name are as expected.
+    arg_str = ", ".join(arg_names)
+    code = (
+        f"""def {name}({arg_str}):
+            return _wrapper({arg_str})
+        """
+        )
+    namespace = {"_wrapper": _wrapper}
+    exec(code, namespace)
+    wrapper = namespace[name]
+    wrapper.__doc__ = docstring
+    return wrapper

v12x/pylib/scipy/special/add_newdocs.py

@@ -0,0 +1,15 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+__all__: list[str] = []
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="special", module="add_newdocs",
+                                   private_modules=["_add_newdocs"], all=__all__,
+                                   attribute=name)

v12x/pylib/scipy/special/basic.py

@@ -0,0 +1,84 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.special` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+__all__ = [  # noqa: F822
+    'ai_zeros',
+    'assoc_laguerre',
+    'bei_zeros',
+    'beip_zeros',
+    'ber_zeros',
+    'bernoulli',
+    'berp_zeros',
+    'bi_zeros',
+    'comb',
+    'digamma',
+    'diric',
+    'erf_zeros',
+    'euler',
+    'factorial',
+    'factorial2',
+    'factorialk',
+    'fresnel_zeros',
+    'fresnelc_zeros',
+    'fresnels_zeros',
+    'gamma',
+    'h1vp',
+    'h2vp',
+    'hankel1',
+    'hankel2',
+    'iv',
+    'ivp',
+    'jn_zeros',
+    'jnjnp_zeros',
+    'jnp_zeros',
+    'jnyn_zeros',
+    'jv',
+    'jvp',
+    'kei_zeros',
+    'keip_zeros',
+    'kelvin_zeros',
+    'ker_zeros',
+    'kerp_zeros',
+    'kv',
+    'kvp',
+    'lmbda',
+    'lqmn',
+    'lqn',
+    'mathieu_a',
+    'mathieu_b',
+    'mathieu_even_coef',
+    'mathieu_odd_coef',
+    'obl_cv_seq',
+    'pbdn_seq',
+    'pbdv_seq',
+    'pbvv_seq',
+    'perm',
+    'polygamma',
+    'pro_cv_seq',
+    'psi',
+    'riccati_jn',
+    'riccati_yn',
+    'sinc',
+    'y0_zeros',
+    'y1_zeros',
+    'y1p_zeros',
+    'yn_zeros',
+    'ynp_zeros',
+    'yv',
+    'yvp',
+    'zeta'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="special", module="basic",
+                                   private_modules=["_basic", "_ufuncs"], all=__all__,
+                                   attribute=name)

v12x/pylib/scipy/special/orthogonal.py

@@ -0,0 +1,45 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.special` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+
+_polyfuns = ['legendre', 'chebyt', 'chebyu', 'chebyc', 'chebys',
+             'jacobi', 'laguerre', 'genlaguerre', 'hermite',
+             'hermitenorm', 'gegenbauer', 'sh_legendre', 'sh_chebyt',
+             'sh_chebyu', 'sh_jacobi']
+
+# Correspondence between new and old names of root functions
+_rootfuns_map = {'roots_legendre': 'p_roots',
+               'roots_chebyt': 't_roots',
+               'roots_chebyu': 'u_roots',
+               'roots_chebyc': 'c_roots',
+               'roots_chebys': 's_roots',
+               'roots_jacobi': 'j_roots',
+               'roots_laguerre': 'l_roots',
+               'roots_genlaguerre': 'la_roots',
+               'roots_hermite': 'h_roots',
+               'roots_hermitenorm': 'he_roots',
+               'roots_gegenbauer': 'cg_roots',
+               'roots_sh_legendre': 'ps_roots',
+               'roots_sh_chebyt': 'ts_roots',
+               'roots_sh_chebyu': 'us_roots',
+               'roots_sh_jacobi': 'js_roots'}
+
+
+__all__ = _polyfuns + list(_rootfuns_map.keys()) + [  # noqa: F822
+    'airy', 'p_roots', 't_roots', 'u_roots', 'c_roots', 's_roots',
+    'j_roots', 'l_roots', 'la_roots', 'h_roots', 'he_roots', 'cg_roots',
+    'ps_roots', 'ts_roots', 'us_roots', 'js_roots'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="special", module="orthogonal",
+                                   private_modules=["_orthogonal"], all=__all__,
+                                   attribute=name)

v12x/pylib/scipy/special/sf_error.py

@@ -0,0 +1,20 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.special` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+__all__ = [  # noqa: F822
+    'SpecialFunctionWarning',
+    'SpecialFunctionError'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="special", module="sf_error",
+                                   private_modules=["_sf_error"], all=__all__,
+                                   attribute=name)

v12x/pylib/scipy/special/specfun.py

@@ -0,0 +1,21 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.special` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+# ruff: noqa: F822
+__all__ = [
+    'lqmn',
+    'pbdv'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="special", module="specfun",
+                                   private_modules=["_basic", "_specfun"], all=__all__,
+                                   attribute=name)

v12x/pylib/scipy/special/spfun_stats.py

@@ -0,0 +1,17 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.special` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+__all__ = ['multigammaln']  # noqa: F822
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="special", module="spfun_stats",
+                                   private_modules=["_spfun_stats"], all=__all__,
+                                   attribute=name)