scipy 1.15.2__cp313-cp313t-macosx_14_0_arm64.whl → 1.16.0__cp313-cp313t-macosx_14_0_arm64.whl

scipy-1.16.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp313-cp313t-macosx_14_0_arm64
+Generator: delocate 0.13.0
+

scipy/_lib/array_api_extra/_funcs.py

@@ -1,484 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ._typing import Array, ModuleType
-
-__all__ = ["atleast_nd", "cov", "create_diagonal", "expand_dims", "kron", "sinc"]
-
-
-def atleast_nd(x: Array, /, *, ndim: int, xp: ModuleType) -> Array:
-    """
-    Recursively expand the dimension of an array to at least `ndim`.
-
-    Parameters
-    ----------
-    x : array
-    ndim : int
-        The minimum number of dimensions for the result.
-    xp : array_namespace
-        The standard-compatible namespace for `x`.
-
-    Returns
-    -------
-    res : array
-        An array with ``res.ndim`` >= `ndim`.
-        If ``x.ndim`` >= `ndim`, `x` is returned.
-        If ``x.ndim`` < `ndim`, `x` is expanded by prepending new axes
-        until ``res.ndim`` equals `ndim`.
-
-    Examples
-    --------
-    >>> import array_api_strict as xp
-    >>> import array_api_extra as xpx
-    >>> x = xp.asarray([1])
-    >>> xpx.atleast_nd(x, ndim=3, xp=xp)
-    Array([[[1]]], dtype=array_api_strict.int64)
-
-    >>> x = xp.asarray([[[1, 2],
-    ...                  [3, 4]]])
-    >>> xpx.atleast_nd(x, ndim=1, xp=xp) is x
-    True
-
-    """
-    if x.ndim < ndim:
-        x = xp.expand_dims(x, axis=0)
-        x = atleast_nd(x, ndim=ndim, xp=xp)
-    return x
-
-
-def cov(m: Array, /, *, xp: ModuleType) -> Array:
-    """
-    Estimate a covariance matrix.
-
-    Covariance indicates the level to which two variables vary together.
-    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
-    then the covariance matrix element :math:`C_{ij}` is the covariance of
-    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
-    of :math:`x_i`.
-
-    This provides a subset of the functionality of ``numpy.cov``.
-
-    Parameters
-    ----------
-    m : array
-        A 1-D or 2-D array containing multiple variables and observations.
-        Each row of `m` represents a variable, and each column a single
-        observation of all those variables.
-    xp : array_namespace
-        The standard-compatible namespace for `m`.
-
-    Returns
-    -------
-    res : array
-        The covariance matrix of the variables.
-
-    Examples
-    --------
-    >>> import array_api_strict as xp
-    >>> import array_api_extra as xpx
-
-    Consider two variables, :math:`x_0` and :math:`x_1`, which
-    correlate perfectly, but in opposite directions:
-
-    >>> x = xp.asarray([[0, 2], [1, 1], [2, 0]]).T
-    >>> x
-    Array([[0, 1, 2],
-           [2, 1, 0]], dtype=array_api_strict.int64)
-
-    Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
-    matrix shows this clearly:
-
-    >>> xpx.cov(x, xp=xp)
-    Array([[ 1., -1.],
-           [-1.,  1.]], dtype=array_api_strict.float64)
-
-
-    Note that element :math:`C_{0,1}`, which shows the correlation between
-    :math:`x_0` and :math:`x_1`, is negative.
-
-    Further, note how `x` and `y` are combined:
-
-    >>> x = xp.asarray([-2.1, -1,  4.3])
-    >>> y = xp.asarray([3,  1.1,  0.12])
-    >>> X = xp.stack((x, y), axis=0)
-    >>> xpx.cov(X, xp=xp)
-    Array([[11.71      , -4.286     ],
-           [-4.286     ,  2.14413333]], dtype=array_api_strict.float64)
-
-    >>> xpx.cov(x, xp=xp)
-    Array(11.71, dtype=array_api_strict.float64)
-
-    >>> xpx.cov(y, xp=xp)
-    Array(2.14413333, dtype=array_api_strict.float64)
-
-    """
-    m = xp.asarray(m, copy=True)
-    dtype = (
-        xp.float64 if xp.isdtype(m.dtype, "integral") else xp.result_type(m, xp.float64)
-    )
-
-    m = atleast_nd(m, ndim=2, xp=xp)
-    m = xp.astype(m, dtype)
-
-    avg = _mean(m, axis=1, xp=xp)
-    fact = m.shape[1] - 1
-
-    if fact <= 0:
-        warnings.warn("Degrees of freedom <= 0 for slice", RuntimeWarning, stacklevel=2)
-        fact = 0.0
-
-    m -= avg[:, None]
-    m_transpose = m.T
-    if xp.isdtype(m_transpose.dtype, "complex floating"):
-        m_transpose = xp.conj(m_transpose)
-    c = m @ m_transpose
-    c /= fact
-    axes = tuple(axis for axis, length in enumerate(c.shape) if length == 1)
-    return xp.squeeze(c, axis=axes)
-
-
-def create_diagonal(x: Array, /, *, offset: int = 0, xp: ModuleType) -> Array:
-    """
-    Construct a diagonal array.
-
-    Parameters
-    ----------
-    x : array
-        A 1-D array
-    offset : int, optional
-        Offset from the leading diagonal (default is ``0``).
-        Use positive ints for diagonals above the leading diagonal,
-        and negative ints for diagonals below the leading diagonal.
-    xp : array_namespace
-        The standard-compatible namespace for `x`.
-
-    Returns
-    -------
-    res : array
-        A 2-D array with `x` on the diagonal (offset by `offset`).
-
-    Examples
-    --------
-    >>> import array_api_strict as xp
-    >>> import array_api_extra as xpx
-    >>> x = xp.asarray([2, 4, 8])
-
-    >>> xpx.create_diagonal(x, xp=xp)
-    Array([[2, 0, 0],
-           [0, 4, 0],
-           [0, 0, 8]], dtype=array_api_strict.int64)
-
-    >>> xpx.create_diagonal(x, offset=-2, xp=xp)
-    Array([[0, 0, 0, 0, 0],
-           [0, 0, 0, 0, 0],
-           [2, 0, 0, 0, 0],
-           [0, 4, 0, 0, 0],
-           [0, 0, 8, 0, 0]], dtype=array_api_strict.int64)
-
-    """
-    if x.ndim != 1:
-        err_msg = "`x` must be 1-dimensional."
-        raise ValueError(err_msg)
-    n = x.shape[0] + abs(offset)
-    diag = xp.zeros(n**2, dtype=x.dtype)
-    i = offset if offset >= 0 else abs(offset) * n
-    diag[i : min(n * (n - offset), diag.shape[0]) : n + 1] = x
-    return xp.reshape(diag, (n, n))
-
-
-def _mean(
-    x: Array,
-    /,
-    *,
-    axis: int | tuple[int, ...] | None = None,
-    keepdims: bool = False,
-    xp: ModuleType,
-) -> Array:
-    """
-    Complex mean, https://github.com/data-apis/array-api/issues/846.
-    """
-    if xp.isdtype(x.dtype, "complex floating"):
-        x_real = xp.real(x)
-        x_imag = xp.imag(x)
-        mean_real = xp.mean(x_real, axis=axis, keepdims=keepdims)
-        mean_imag = xp.mean(x_imag, axis=axis, keepdims=keepdims)
-        return mean_real + (mean_imag * xp.asarray(1j))
-    return xp.mean(x, axis=axis, keepdims=keepdims)
-
-
-def expand_dims(
-    a: Array, /, *, axis: int | tuple[int, ...] = (0,), xp: ModuleType
-) -> Array:
-    """
-    Expand the shape of an array.
-
-    Insert (a) new axis/axes that will appear at the position(s) specified by
-    `axis` in the expanded array shape.
-
-    This is ``xp.expand_dims`` for `axis` an int *or a tuple of ints*.
-    Roughly equivalent to ``numpy.expand_dims`` for NumPy arrays.
-
-    Parameters
-    ----------
-    a : array
-    axis : int or tuple of ints, optional
-        Position(s) in the expanded axes where the new axis (or axes) is/are placed.
-        If multiple positions are provided, they should be unique (note that a position
-        given by a positive index could also be referred to by a negative index -
-        that will also result in an error).
-        Default: ``(0,)``.
-    xp : array_namespace
-        The standard-compatible namespace for `a`.
-
-    Returns
-    -------
-    res : array
-        `a` with an expanded shape.
-
-    Examples
-    --------
-    >>> import array_api_strict as xp
-    >>> import array_api_extra as xpx
-    >>> x = xp.asarray([1, 2])
-    >>> x.shape
-    (2,)
-
-    The following is equivalent to ``x[xp.newaxis, :]`` or ``x[xp.newaxis]``:
-
-    >>> y = xpx.expand_dims(x, axis=0, xp=xp)
-    >>> y
-    Array([[1, 2]], dtype=array_api_strict.int64)
-    >>> y.shape
-    (1, 2)
-
-    The following is equivalent to ``x[:, xp.newaxis]``:
-
-    >>> y = xpx.expand_dims(x, axis=1, xp=xp)
-    >>> y
-    Array([[1],
-           [2]], dtype=array_api_strict.int64)
-    >>> y.shape
-    (2, 1)
-
-    ``axis`` may also be a tuple:
-
-    >>> y = xpx.expand_dims(x, axis=(0, 1), xp=xp)
-    >>> y
-    Array([[[1, 2]]], dtype=array_api_strict.int64)
-
-    >>> y = xpx.expand_dims(x, axis=(2, 0), xp=xp)
-    >>> y
-    Array([[[1],
-            [2]]], dtype=array_api_strict.int64)
-
-    """
-    if not isinstance(axis, tuple):
-        axis = (axis,)
-    ndim = a.ndim + len(axis)
-    if axis != () and (min(axis) < -ndim or max(axis) >= ndim):
-        err_msg = (
-            f"a provided axis position is out of bounds for array of dimension {a.ndim}"
-        )
-        raise IndexError(err_msg)
-    axis = tuple(dim % ndim for dim in axis)
-    if len(set(axis)) != len(axis):
-        err_msg = "Duplicate dimensions specified in `axis`."
-        raise ValueError(err_msg)
-    for i in sorted(axis):
-        a = xp.expand_dims(a, axis=i)
-    return a
-
-
-def kron(a: Array, b: Array, /, *, xp: ModuleType) -> Array:
-    """
-    Kronecker product of two arrays.
-
-    Computes the Kronecker product, a composite array made of blocks of the
-    second array scaled by the first.
-
-    Equivalent to ``numpy.kron`` for NumPy arrays.
-
-    Parameters
-    ----------
-    a, b : array
-    xp : array_namespace
-        The standard-compatible namespace for `a` and `b`.
-
-    Returns
-    -------
-    res : array
-        The Kronecker product of `a` and `b`.
-
-    Notes
-    -----
-    The function assumes that the number of dimensions of `a` and `b`
-    are the same, if necessary prepending the smallest with ones.
-    If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``,
-    the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``.
-    The elements are products of elements from `a` and `b`, organized
-    explicitly by::
-
-        kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
-
-    where::
-
-        kt = it * st + jt,  t = 0,...,N
-
-    In the common 2-D case (N=1), the block structure can be visualized::
-
-        [[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
-         [  ...                              ...   ],
-         [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
-
-
-    Examples
-    --------
-    >>> import array_api_strict as xp
-    >>> import array_api_extra as xpx
-    >>> xpx.kron(xp.asarray([1, 10, 100]), xp.asarray([5, 6, 7]), xp=xp)
-    Array([  5,   6,   7,  50,  60,  70, 500,
-           600, 700], dtype=array_api_strict.int64)
-
-    >>> xpx.kron(xp.asarray([5, 6, 7]), xp.asarray([1, 10, 100]), xp=xp)
-    Array([  5,  50, 500,   6,  60, 600,   7,
-            70, 700], dtype=array_api_strict.int64)
-
-    >>> xpx.kron(xp.eye(2), xp.ones((2, 2)), xp=xp)
-    Array([[1., 1., 0., 0.],
-           [1., 1., 0., 0.],
-           [0., 0., 1., 1.],
-           [0., 0., 1., 1.]], dtype=array_api_strict.float64)
-
-
-    >>> a = xp.reshape(xp.arange(100), (2, 5, 2, 5))
-    >>> b = xp.reshape(xp.arange(24), (2, 3, 4))
-    >>> c = xpx.kron(a, b, xp=xp)
-    >>> c.shape
-    (2, 10, 6, 20)
-    >>> I = (1, 3, 0, 2)
-    >>> J = (0, 2, 1)
-    >>> J1 = (0,) + J             # extend to ndim=4
-    >>> S1 = (1,) + b.shape
-    >>> K = tuple(xp.asarray(I) * xp.asarray(S1) + xp.asarray(J1))
-    >>> c[K] == a[I]*b[J]
-    Array(True, dtype=array_api_strict.bool)
-
-    """
-
-    b = xp.asarray(b)
-    singletons = (1,) * (b.ndim - a.ndim)
-    a = xp.broadcast_to(xp.asarray(a), singletons + a.shape)
-
-    nd_b, nd_a = b.ndim, a.ndim
-    nd_max = max(nd_b, nd_a)
-    if nd_a == 0 or nd_b == 0:
-        return xp.multiply(a, b)
-
-    a_shape = a.shape
-    b_shape = b.shape
-
-    # Equalise the shapes by prepending smaller one with 1s
-    a_shape = (1,) * max(0, nd_b - nd_a) + a_shape
-    b_shape = (1,) * max(0, nd_a - nd_b) + b_shape
-
-    # Insert empty dimensions
-    a_arr = expand_dims(a, axis=tuple(range(nd_b - nd_a)), xp=xp)
-    b_arr = expand_dims(b, axis=tuple(range(nd_a - nd_b)), xp=xp)
-
-    # Compute the product
-    a_arr = expand_dims(a_arr, axis=tuple(range(1, nd_max * 2, 2)), xp=xp)
-    b_arr = expand_dims(b_arr, axis=tuple(range(0, nd_max * 2, 2)), xp=xp)
-    result = xp.multiply(a_arr, b_arr)
-
-    # Reshape back and return
-    a_shape = xp.asarray(a_shape)
-    b_shape = xp.asarray(b_shape)
-    return xp.reshape(result, tuple(xp.multiply(a_shape, b_shape)))
-
-
-def sinc(x: Array, /, *, xp: ModuleType) -> Array:
-    r"""
-    Return the normalized sinc function.
-
-    The sinc function is equal to :math:`\sin(\pi x)/(\pi x)` for any argument
-    :math:`x\ne 0`. ``sinc(0)`` takes the limit value 1, making ``sinc`` not
-    only everywhere continuous but also infinitely differentiable.
-
-    .. note::
-
-        Note the normalization factor of ``pi`` used in the definition.
-        This is the most commonly used definition in signal processing.
-        Use ``sinc(x / xp.pi)`` to obtain the unnormalized sinc function
-        :math:`\sin(x)/x` that is more common in mathematics.
-
-    Parameters
-    ----------
-    x : array
-        Array (possibly multi-dimensional) of values for which to calculate
-        ``sinc(x)``. Must have a real floating point dtype.
-    xp : array_namespace
-        The standard-compatible namespace for `x`.
-
-    Returns
-    -------
-    res : array
-        ``sinc(x)`` calculated elementwise, which has the same shape as the input.
-
-    Notes
-    -----
-    The name sinc is short for "sine cardinal" or "sinus cardinalis".
-
-    The sinc function is used in various signal processing applications,
-    including in anti-aliasing, in the construction of a Lanczos resampling
-    filter, and in interpolation.
-
-    For bandlimited interpolation of discrete-time signals, the ideal
-    interpolation kernel is proportional to the sinc function.
-
-    References
-    ----------
-    .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web
-           Resource. https://mathworld.wolfram.com/SincFunction.html
-    .. [2] Wikipedia, "Sinc function",
-           https://en.wikipedia.org/wiki/Sinc_function
-
-    Examples
-    --------
-    >>> import array_api_strict as xp
-    >>> import array_api_extra as xpx
-    >>> x = xp.linspace(-4, 4, 41)
-    >>> xpx.sinc(x, xp=xp)
-    Array([-3.89817183e-17, -4.92362781e-02,
-           -8.40918587e-02, -8.90384387e-02,
-           -5.84680802e-02,  3.89817183e-17,
-            6.68206631e-02,  1.16434881e-01,
-            1.26137788e-01,  8.50444803e-02,
-           -3.89817183e-17, -1.03943254e-01,
-           -1.89206682e-01, -2.16236208e-01,
-           -1.55914881e-01,  3.89817183e-17,
-            2.33872321e-01,  5.04551152e-01,
-            7.56826729e-01,  9.35489284e-01,
-            1.00000000e+00,  9.35489284e-01,
-            7.56826729e-01,  5.04551152e-01,
-            2.33872321e-01,  3.89817183e-17,
-           -1.55914881e-01, -2.16236208e-01,
-           -1.89206682e-01, -1.03943254e-01,
-           -3.89817183e-17,  8.50444803e-02,
-            1.26137788e-01,  1.16434881e-01,
-            6.68206631e-02,  3.89817183e-17,
-           -5.84680802e-02, -8.90384387e-02,
-           -8.40918587e-02, -4.92362781e-02,
-           -3.89817183e-17], dtype=array_api_strict.float64)
-
-    """
-    if not xp.isdtype(x.dtype, "real floating"):
-        err_msg = "`x` must have a real floating data type."
-        raise ValueError(err_msg)
-    # no scalars in `where` - array-api#807
-    y = xp.pi * xp.where(
-        x, x, xp.asarray(xp.finfo(x.dtype).smallest_normal, dtype=x.dtype)
-    )
-    return xp.sin(y) / y

scipy/_lib/array_api_extra/_typing.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-from types import ModuleType
-from typing import Any
-
-Array = Any  # To be changed to a Protocol later (see array-api#589)
-
-__all__ = ["Array", "ModuleType"]

scipy/spatial/qhull_src/COPYING.txt

@@ -1,38 +0,0 @@
-                    Qhull, Copyright (c) 1993-2019
-                    
-                            C.B. Barber
-                           Arlington, MA 
-                          
-                               and
-
-       The National Science and Technology Research Center for
-        Computation and Visualization of Geometric Structures
-                        (The Geometry Center)
-                       University of Minnesota
-
-                       email: qhull@qhull.org
-
-This software includes Qhull from C.B. Barber and The Geometry Center.  
-Qhull is copyrighted as noted above.  Qhull is free software and may 
-be obtained via http from www.qhull.org.  It may be freely copied, modified, 
-and redistributed under the following conditions:
-
-1. All copyright notices must remain intact in all files.
-
-2. A copy of this text file must be distributed along with any copies 
-   of Qhull that you redistribute; this includes copies that you have 
-   modified, or copies of programs or other software products that 
-   include Qhull.
-
-3. If you modify Qhull, you must include a notice giving the
-   name of the person performing the modification, the date of
-   modification, and the reason for such modification.
-
-4. When distributing modified versions of Qhull, or other software 
-   products that include Qhull, you must provide notice that the original 
-   source code may be obtained as noted above.
-
-5. There is no warranty or other guarantee of fitness for Qhull, it is 
-   provided solely "as is".  Bug reports or fixes may be sent to 
-   qhull_bug@qhull.org; the authors may or may not act on them as 
-   they desire.

scipy/special/tests/test_log_softmax.py

@@ -1,109 +0,0 @@
-import numpy as np
-from numpy.testing import assert_allclose
-
-import pytest
-
-import scipy.special as sc
-
-
-@pytest.mark.parametrize('x, expected', [
-    (np.array([1000, 1]), np.array([0, -999])),
-
-    # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
-    # converted to float.
-    (np.arange(4), np.array([-3.4401896985611953,
-                             -2.4401896985611953,
-                             -1.4401896985611953,
-                             -0.44018969856119533]))
-])
-def test_log_softmax(x, expected):
-    assert_allclose(sc.log_softmax(x), expected, rtol=1e-13)
-
-
-@pytest.fixture
-def log_softmax_x():
-    x = np.arange(4)
-    return x
-
-
-@pytest.fixture
-def log_softmax_expected():
-    # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
-    # converted to float.
-    expected = np.array([-3.4401896985611953,
-                         -2.4401896985611953,
-                         -1.4401896985611953,
-                         -0.44018969856119533])
-    return expected
-
-
-def test_log_softmax_translation(log_softmax_x, log_softmax_expected):
-    # Translation property.  If all the values are changed by the same amount,
-    # the softmax result does not change.
-    x = log_softmax_x + 100
-    expected = log_softmax_expected
-    assert_allclose(sc.log_softmax(x), expected, rtol=1e-13)
-
-
-def test_log_softmax_noneaxis(log_softmax_x, log_softmax_expected):
-    # When axis=None, softmax operates on the entire array, and preserves
-    # the shape.
-    x = log_softmax_x.reshape(2, 2)
-    expected = log_softmax_expected.reshape(2, 2)
-    assert_allclose(sc.log_softmax(x), expected, rtol=1e-13)
-
-
-@pytest.mark.parametrize('axis_2d, expected_2d', [
-    (0, np.log(0.5) * np.ones((2, 2))),
-    (1, np.array([[0, -999], [0, -999]]))
-])
-def test_axes(axis_2d, expected_2d):
-    assert_allclose(
-        sc.log_softmax([[1000, 1], [1000, 1]], axis=axis_2d),
-        expected_2d,
-        rtol=1e-13,
-    )
-
-
-@pytest.fixture
-def log_softmax_2d_x():
-    x = np.arange(8).reshape(2, 4)
-    return x
-
-
-@pytest.fixture
-def log_softmax_2d_expected():
-    # Expected value computed using mpmath (with mpmath.mp.dps = 200) and then
-    # converted to float.
-    expected = np.array([[-3.4401896985611953,
-                         -2.4401896985611953,
-                         -1.4401896985611953,
-                         -0.44018969856119533],
-                        [-3.4401896985611953,
-                         -2.4401896985611953,
-                         -1.4401896985611953,
-                         -0.44018969856119533]])
-    return expected
-
-
-def test_log_softmax_2d_axis1(log_softmax_2d_x, log_softmax_2d_expected):
-    x = log_softmax_2d_x
-    expected = log_softmax_2d_expected
-    assert_allclose(sc.log_softmax(x, axis=1), expected, rtol=1e-13)
-
-
-def test_log_softmax_2d_axis0(log_softmax_2d_x, log_softmax_2d_expected):
-    x = log_softmax_2d_x.T
-    expected = log_softmax_2d_expected.T
-    assert_allclose(sc.log_softmax(x, axis=0), expected, rtol=1e-13)
-
-
-def test_log_softmax_3d(log_softmax_2d_x, log_softmax_2d_expected):
-    # 3-d input, with a tuple for the axis.
-    x_3d = log_softmax_2d_x.reshape(2, 2, 2)
-    expected_3d = log_softmax_2d_expected.reshape(2, 2, 2)
-    assert_allclose(sc.log_softmax(x_3d, axis=(1, 2)), expected_3d, rtol=1e-13)
-
-
-def test_log_softmax_scalar():
-    assert_allclose(sc.log_softmax(1.0), 0.0, rtol=1e-13)