scipy 1.15.3__cp313-cp313t-macosx_14_0_arm64.whl → 1.16.0rc2__cp313-cp313t-macosx_14_0_arm64.whl

scipy/sparse/tests/test_coo.py

@@ -1,8 +1,9 @@
+import math
 import numpy as np
-from numpy.testing import assert_equal
+from numpy.testing import assert_equal, assert_allclose, suppress_warnings
 import pytest
 from scipy.linalg import block_diag
-from scipy.sparse import coo_array, random_array
+from scipy.sparse import coo_array, random_array, SparseEfficiencyWarning
 from .._coo import _block_diag, _extract_block_diag
 
 
@@ -563,8 +564,7 @@ def test_nd_add_sparse_with_inconsistent_shapes(a_shape, b_shape):
 
     arr_a = random_array((a_shape), density=0.6, rng=rng, dtype=int)
     arr_b = random_array((b_shape), density=0.6, rng=rng, dtype=int)
-    with pytest.raises(ValueError,
-                       match="(Incompatible|inconsistent) shapes|cannot be broadcast"):
+    with pytest.raises(ValueError, match="inconsistent shapes"):
         arr_a + arr_b
 
 
@@ -849,3 +849,271 @@ def test_extract_block_diag(shape):
     res = _extract_block_diag(_block_diag(sp_x), shape)
 
     assert_equal(res.toarray(), sp_x.toarray())
+
+
+add_sub_shapes = [
+    ((3,4), (3,4)), ((3,4,6), (3,4,6)), ((3,7,5), (3,7,5))
+]
+@pytest.mark.parametrize(('a_shape', 'b_shape'), add_sub_shapes)
+def test_add_no_broadcasting(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a + b
+    exp = np.add(a.toarray(), b.toarray())
+    assert_equal(res.toarray(), exp)
+    res = a + b.toarray()
+    assert_equal(res, exp)
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), add_sub_shapes)
+def test_sub_no_broadcasting(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a - b
+    exp = np.subtract(a.toarray(), b.toarray())
+    assert_equal(res.toarray(), exp)
+
+    res = a - b.toarray()
+    assert_equal(res, exp)
+
+argmax_argmin_shapes_axis = [
+    ((3,), None), ((3,), 0),
+    ((4,6), 1), ((7,3), 0), ((3,5), None),
+    ((2,8,7), 2), ((2,8,7), 0),
+    ((2,0), 0), ((3,0,0,2), 0),
+    ((3,2,4,7), None), ((3,2,4,7), 1), ((3,2,4,7), 0), ((3,2,4,7), 2),
+    ((3,2,4,7), -2), ((4,5,7,8,2), 4), ((4,5,7,8,2), -3),
+]
+@pytest.mark.parametrize(('shape', 'axis'), argmax_argmin_shapes_axis)
+def test_argmax_argmin(shape, axis):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a.argmax(axis=axis)
+    exp = np.argmax(a.toarray(), axis=axis)
+    assert_equal(res, exp)
+
+    res = a.argmin(axis=axis)
+    exp = np.argmin(a.toarray(), axis=axis)
+    assert_equal(res, exp)
+
+
+max_min_shapes_axis = [
+    ((3,), None), ((3,), 0),
+    ((4,6), 1), ((7,3), 0), ((3,5), None),
+    ((2,8,7), 2), ((2,8,7), 0),
+    ((3,2,4,7), None), ((3,2,4,7), 1), ((3,2,4,7), 0), ((3,2,4,7), 2),
+    ((4,5,7,8,2), 4), ((4,5,8,1), 3), ((4,6), (0,)), ((4,6), (0,1)),
+    ((3,0,2), 2), ((3,0,2), (0,2)), ((3,0), 0),
+    ((3,7,8,5), (0,1)), ((3,7,8,5), (2,1)), ((3,7,8,5), (2,0)),
+    ((3,7,8,5), (0,-2)), ((3,7,8,5), (-1,2)), ((3,7,8,5), (3)),
+    ((3,7,8,5), (0,1,2)), ((3,7,8,5), (0,1,2,3)),
+]
+@pytest.mark.parametrize(('shape', 'axis'), max_min_shapes_axis)
+def test_min_max(shape, axis):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res_min = a.min(axis=axis)
+    exp_min = np.min(a.toarray(), axis=axis)
+    res_max = a.max(axis=axis)
+    exp_max = np.max(a.toarray(), axis=axis)
+    res_nanmin = a.nanmin(axis=axis)
+    exp_nanmin = np.nanmin(a.toarray(), axis=axis)
+    res_nanmax = a.nanmax(axis=axis)
+    exp_nanmax = np.nanmax(a.toarray(), axis=axis)
+
+    for res, exp in [(res_min, exp_min), (res_max, exp_max),
+                     (res_nanmin, exp_nanmin), (res_nanmax, exp_nanmax)]:
+        if np.issubdtype(type(res), np.number):
+            assert_equal(res, exp)
+        else:
+            assert_equal(res.toarray(), exp)
+
+
+def test_min_max_full():
+    for a in (coo_array([[[1, 2, 3, 4]]]), coo_array([[1, 2, 3, 4]])):
+        assert a.min() == 1
+        assert (-a).max() == -1
+
+
+sum_mean_params = [
+    ((3,), None, None), ((3,), 0, None),
+    ((4,6), 1, None), ((7,3), 0, None), ((3,5), None, None),
+    ((2,8,7), 2, None), ((2,8,7), 0, np.zeros((8,7))),
+    ((3,2,4,7), None, None), ((3,2,4,7), 1, np.zeros((3,4,7))),
+    ((3,2,4,7), 0, None), ((4,5,7,8,2), 4, None),
+    ((4,5,8,1), 3, None), ((4,6), (0,), None), ((4,6), (0,1), None),
+    ((3,0,2), 2, None), ((3,0,2), (0,2), None), ((3,0), 0, None),
+    ((3,7,8,5), (0,1), np.zeros((8,5))), ((3,7,8,5), (2,1), None),
+    ((3,7,8,5), (0,-2), None), ((3,7,8,5), (-1,2), np.zeros((3,7))),
+    ((3,7,8,5), (3), None), ((3,7,8,5), (0,1,2), np.zeros((5,))),
+    ((3,7,8,5), (0,1,2,3), None),
+]
+@pytest.mark.parametrize(('shape', 'axis', 'out'), sum_mean_params)
+def test_sum(shape, axis, out):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a.sum(axis=axis, out=out)
+    exp = np.sum(a.toarray(), axis=axis)
+    assert_equal(res, exp)
+    if out is not None:
+        assert_equal(out, exp)
+        assert id(res) == id(out)
+
+
+@pytest.mark.parametrize(('shape', 'axis', 'out'), sum_mean_params)
+def test_mean(shape, axis, out):
+    rng = np.random.default_rng(23409823)
+    a = random_array(shape, density=0.6, random_state=rng, dtype=int)
+
+    res = a.mean(axis=axis, out=out)
+    exp = np.mean(a.toarray(), axis=axis)
+    assert_allclose(res, exp)
+    if out is not None:
+        assert id(res) == id(out)
+        assert_allclose(out, exp)
+
+
+def test_pow_abs_round():
+    rng = np.random.default_rng(23409823)
+    a = random_array((3,6,5,2,4), density=0.6, random_state=rng, dtype=int)
+    assert_allclose((a**3).toarray(), np.power(a.toarray(), 3))
+    assert_allclose((a**7).toarray(), np.power(a.toarray(), 7))
+    assert_allclose(round(a).toarray(), np.round(a.toarray()))
+    assert_allclose(abs(a).toarray(), np.abs(a.toarray()))
+
+
+#bitwise_op_and_compare_broadcast_shapes = [
+#    ((3,4), (3,4)), ((1,4), (2,1)), ((3,5), (1,)), ((1,), (7,8)),
+#    ((3,4,6), (3,4,6)), ((4,3), (2,1,3)), ((2,1,3), (4,3)),
+#    ((3,5,4), (1,)), ((1,), (7,8,4)), ((16,1,6), (2,6)), ((3,7,5), (3,7,5)),
+#    ((16,2,6), (1,2,6)), ((7,8), (5,7,8)), ((4,5,1), (5,1)),
+#    ((6,8,3), (4,1,1,3)), ((1,1,1), (3,4,2)), ((3,4,2), (1,1,1,1,1)),
+bitwise_op_and_compare_shapes = [
+    ((3,4), (3,4)), ((3,4,6), (3,4,6)), ((3,7,5), (3,7,5)),
+]
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_boolean_comparisons(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    with sup:
+        assert_equal((a==b).toarray(), a.toarray()==b.toarray())
+        assert_equal((a!=b).toarray(), a.toarray()!=b.toarray())
+        assert_equal((a>=b).toarray(), a.toarray()>=b.toarray())
+        assert_equal((a<=b).toarray(), a.toarray()<=b.toarray())
+        assert_equal((a>b).toarray(), a.toarray()>b.toarray())
+        assert_equal((a<b).toarray(), a.toarray()<b.toarray())
+        assert_equal((a==b).toarray(), np.bitwise_not((a!=b).toarray()))
+        assert_equal((a>=b).toarray(), np.bitwise_not((a<b).toarray()))
+        assert_equal((a<=b).toarray(), np.bitwise_not((a>b).toarray()))
+
+
+def test_boolean_comparisons_with_scalar():
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array((5,4,8,7), density=0.6, random_state=rng, dtype=int)
+    with sup:
+        assert_equal((a==0).toarray(), a.toarray()==0)
+        assert_equal((a!=0).toarray(), a.toarray()!=0)
+        assert_equal((a>=1).toarray(), a.toarray()>=1)
+        assert_equal((a<=1).toarray(), a.toarray()<=1)
+        assert_equal((a>0).toarray(), a.toarray()>0)
+        assert_equal((a<0).toarray(), a.toarray()<0)
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_multiply(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    res = a * b
+    exp = np.multiply(a.toarray(), b.toarray())
+    assert_equal(res.toarray(), exp)
+
+
+def test_multiply_with_scalar():
+    rng = np.random.default_rng(23409823)
+    a = random_array((3,5,4), density=0.6, random_state=rng, dtype=int)
+    res = a * 7
+    exp = np.multiply(a.toarray(), 7)
+    assert_equal(res.toarray(), exp)
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_divide(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = np.arange(1, 1 + math.prod(b_shape)).reshape(b_shape)
+    res = a / b
+    exp = a.toarray() / b
+    assert_allclose(res.toarray(), exp)
+
+    res = a / b
+    assert_allclose(res.toarray(), exp)
+
+
+def test_divide_with_scalar():
+    rng = np.random.default_rng(23409823)
+    a = random_array((3,5,4), density=0.6, random_state=rng, dtype=int)
+    res = a / 7
+    exp = a.toarray() / 7
+    assert_allclose(res.toarray(), exp)
+
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_maximum(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    with sup:
+        res = a.maximum(b)
+        exp = np.maximum(a.toarray(), b.toarray())
+        assert_equal(res.toarray(), exp)
+
+@pytest.mark.parametrize(('a_shape', 'b_shape'), bitwise_op_and_compare_shapes)
+def test_minimum(a_shape, b_shape):
+    rng = np.random.default_rng(23409823)
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = random_array(a_shape, density=0.6, random_state=rng, dtype=int)
+    b = random_array(b_shape, density=0.6, random_state=rng, dtype=int)
+    with sup:
+        res = a.minimum(b)
+        exp = np.minimum(a.toarray(), b.toarray())
+        assert_equal(res.toarray(), exp)
+
+
+def test_maximum_with_scalar():
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = coo_array([0,1,6])
+    b = coo_array([[15, 0], [14, 5], [0, -12]])
+    c = coo_array([[[[3,0], [2,4]], [[8,9], [-3,12]]],
+                   [[[5,2], [3,0]], [[0,7], [0,-6]]]])
+    with sup:
+        assert_equal(a.maximum(5).toarray(), np.maximum(a.toarray(), 5))
+        assert_equal(b.maximum(9).toarray(), np.maximum(b.toarray(), 9))
+        assert_equal(c.maximum(5).toarray(), np.maximum(c.toarray(), 5))
+
+def test_minimum_with_scalar():
+    sup = suppress_warnings()
+    sup.filter(SparseEfficiencyWarning)
+    a = coo_array([0,1,6])
+    b = coo_array([[15, 0], [14, 5], [0, -12]])
+    c = coo_array([[[[3,0], [2,4]], [[8,9], [-3,12]]],
+                   [[[5,2], [3,0]], [[0,7], [0,-6]]]])
+    with sup:
+        assert_equal(a.minimum(5).toarray(), np.minimum(a.toarray(), 5))
+        assert_equal(b.minimum(9).toarray(), np.minimum(b.toarray(), 9))
+        assert_equal(c.minimum(5).toarray(), np.minimum(c.toarray(), 5))

scipy/sparse/tests/test_sparsetools.py

@@ -21,6 +21,7 @@ def int_to_int8(n):
     return (n + 128) % 256 - 128
 
 
+@pytest.mark.thread_unsafe  # Exception handling in CPython 3.13 has races
 def test_exception():
     assert_raises(MemoryError, _sparsetools.test_throw_error)
 
@@ -68,6 +69,7 @@ def test_regression_std_vector_dtypes():
 
 
 @pytest.mark.slow
+@pytest.mark.thread_unsafe
 @pytest.mark.xfail_on_32bit("Can't create large array for test")
 def test_nnz_overflow():
     # Regression test for gh-7230 / gh-7871, checking that coo_toarray
@@ -88,6 +90,7 @@ def test_nnz_overflow():
     assert_allclose(d, [[4]])
 
 
+@pytest.mark.thread_unsafe
 @pytest.mark.skipif(
     not (sys.platform.startswith('linux') and np.dtype(np.intp).itemsize >= 8),
     reason="test requires 64-bit Linux"
@@ -117,6 +120,7 @@ class TestInt32Overflow:
     def teardown_method(self):
         gc.collect()
 
+    @pytest.mark.fail_slow(2)  # keep in fast set, only non-slow test
     def test_coo_todense(self):
         # Check *_todense routines (cf. gh-2179)
         #
@@ -270,6 +274,7 @@ class TestInt32Overflow:
         m2.dot(m)  # shouldn't SIGSEGV
 
 
+@pytest.mark.thread_unsafe
 @pytest.mark.skip(reason="64-bit indices in sparse matrices not available")
 def test_csr_matmat_int64_overflow():
     n = 3037000500

scipy/sparse/tests/test_sputils.py

@@ -107,13 +107,42 @@ class TestSparseUtils:
         assert_equal(sputils.isdense(matrix([1])), True)
 
     def test_validateaxis(self):
-        assert_raises(TypeError, sputils.validateaxis, (0, 1))
-        assert_raises(TypeError, sputils.validateaxis, 1.5)
-        assert_raises(ValueError, sputils.validateaxis, 3)
-
-        # These function calls should not raise errors
-        for axis in (-2, -1, 0, 1, None):
-            sputils.validateaxis(axis)
+        with assert_raises(ValueError, match="does not accept 0D axis"):
+            sputils.validateaxis(())
+
+        for ax in [1.5, (0, 1.5), (1.5, 0)]:
+            with assert_raises(TypeError, match="must be an integer"):
+                sputils.validateaxis(ax)
+        for ax in [(1, 1), (1, -1), (0, -2)]:
+            with assert_raises(ValueError, match="duplicate value in axis"):
+                sputils.validateaxis(ax)
+
+        # ndim 1
+        for ax in [1, -2, (0, 1), (1, -1)]:
+            with assert_raises(ValueError, match="out of range"):
+                sputils.validateaxis(ax, ndim=1)
+        with assert_raises(ValueError, match="duplicate value in axis"):
+            sputils.validateaxis((0, -1), ndim=1)
+        # all valid axis values lead to None when canonical
+        for axis in (0, -1, None, (0,), (-1,)):
+            assert sputils.validateaxis(axis, ndim=1) is None
+
+        # ndim 2
+        for ax in [5, -5, (0, 5), (-5, 0)]:
+            with assert_raises(ValueError, match="out of range"):
+                sputils.validateaxis(ax, ndim=2)
+        for axis in ((0,), (1,), None):
+            assert sputils.validateaxis(axis, ndim=2) == axis
+        axis_2d = {-2: (0,), -1: (1,), 0: (0,), 1: (1,), (0, 1): None, (0, -1): None}
+        for axis, canonical_axis in axis_2d.items():
+            assert sputils.validateaxis(axis, ndim=2) == canonical_axis
+
+        # ndim 4
+        for axis in ((2,), (3,), (2, 3), (2, 1), (0, 3)):
+            assert sputils.validateaxis(axis, ndim=4) == axis
+        axis_4d = {-4: (0,), -3: (1,), 2: (2,), 3: (3,), (3, -4): (3, 0)}
+        for axis, canonical_axis in axis_4d.items():
+            sputils.validateaxis(axis, ndim=4) == canonical_axis
 
     @pytest.mark.parametrize("container", [csr_array, bsr_array])
     def test_safely_cast_index_compressed(self, container):

scipy/spatial/distance.py

@@ -107,20 +107,19 @@ __all__ = [
 
 import math
 import warnings
-import numpy as np
 import dataclasses
-
 from collections.abc import Callable
 from functools import partial
-from scipy._lib._util import _asarray_validated, _transition_to_rng
-from scipy._lib.deprecation import _deprecated
 
-from . import _distance_wrap
-from . import _hausdorff
-from ..linalg import norm
-from ..special import rel_entr
+import numpy as np
 
-from . import _distance_pybind
+from scipy._lib._array_api import _asarray
+from scipy._lib._util import _asarray_validated, _transition_to_rng
+from scipy._lib import array_api_extra as xpx
+from scipy._lib.deprecation import _deprecated
+from scipy.linalg import norm
+from scipy.special import rel_entr
+from . import _hausdorff, _distance_pybind, _distance_wrap
 
 
 def _copy_array_if_base_present(a):
@@ -222,9 +221,8 @@ def _validate_hamming_kwargs(X, m, n, **kwargs):
     w = kwargs.get('w', np.ones((n,), dtype='double'))
 
     if w.ndim != 1 or w.shape[0] != n:
-        raise ValueError(
-            "Weights must have same size as input vector. %d vs. %d" % (w.shape[0], n)
-        )
+        raise ValueError(f"Weights must have same size as input vector. "
+                         f"{w.shape[0]} vs. {n}")
 
     kwargs['w'] = _validate_weights(w)
     return kwargs
@@ -236,11 +234,10 @@ def _validate_mahalanobis_kwargs(X, m, n, **kwargs):
         if m <= n:
             # There are fewer observations than the dimension of
             # the observations.
-            raise ValueError("The number of observations (%d) is too "
-                             "small; the covariance matrix is "
-                             "singular. For observations with %d "
-                             "dimensions, at least %d observations "
-                             "are required." % (m, n, n + 1))
+            raise ValueError(
+                f"The number of observations ({m}) is too small; "
+                f"the covariance matrix is singular. For observations "
+                f"with {n} dimensions, at least {n + 1} observations are required.")
         if isinstance(X, tuple):
             X = np.vstack(X)
         CV = np.atleast_2d(np.cov(X.astype(np.float64, copy=False).T))
@@ -2295,14 +2292,33 @@ def pdist(X, metric='euclidean', *, out=None, **kwargs):
     # between all pairs of vectors in X using the distance metric 'abc' but
     # with a more succinct, verifiable, but less efficient implementation.
 
+    X = _asarray(X)
+    if X.ndim != 2:
+        raise ValueError(f'A 2-dimensional array must be passed. (Shape was {X.shape}).')
+
+    n = X.shape[0]
+    return xpx.lazy_apply(_np_pdist, X, out,
+                          # lazy_apply doesn't support Array kwargs
+                          kwargs.pop('w', None),
+                          kwargs.pop('V', None),
+                          kwargs.pop('VI', None),
+                          # See src/distance_pybind.cpp::pdist
+                          shape=((n * (n - 1)) // 2, ), dtype=X.dtype, 
+                          as_numpy=True, metric=metric, **kwargs)
+
+
+def _np_pdist(X, out, w, V, VI, metric='euclidean', **kwargs):
+
     X = _asarray_validated(X, sparse_ok=False, objects_ok=True, mask_ok=True,
                            check_finite=False)
+    m, n = X.shape
 
-    s = X.shape
-    if len(s) != 2:
-        raise ValueError('A 2-dimensional array must be passed.')
-
-    m, n = s
+    if w is not None:
+        kwargs["w"] = w
+    if V is not None:
+        kwargs["V"] = V
+    if VI is not None:
+        kwargs["VI"] = VI
 
     if callable(metric):
         mstr = getattr(metric, '__name__', 'UnknownCustomMetric')
@@ -2622,7 +2638,7 @@ def is_valid_y(y, warning=False, throw=False, name=None):
     throw : bool, optional
         Throws an exception if the variable passed is not a valid
         condensed distance matrix.
-    name : bool, optional
+    name : str, optional
         Used when referencing the offending variable in the
         warning or exception message.
 
@@ -2650,34 +2666,25 @@ def is_valid_y(y, warning=False, throw=False, name=None):
     False
 
     """
-    y = np.asarray(y, order='c')
-    valid = True
+    y = _asarray(y)
+    name_str = f"'{name}' " if name else ""
     try:
         if len(y.shape) != 1:
-            if name:
-                raise ValueError(f"Condensed distance matrix '{name}' must "
-                                 "have shape=1 (i.e. be one-dimensional).")
-            else:
-                raise ValueError('Condensed distance matrix must have shape=1 '
-                                 '(i.e. be one-dimensional).')
+            raise ValueError(f"Condensed distance matrix {name_str}must "
+                             "have shape=1 (i.e. be one-dimensional).")
         n = y.shape[0]
         d = int(np.ceil(np.sqrt(n * 2)))
         if (d * (d - 1) / 2) != n:
-            if name:
-                raise ValueError(f"Length n of condensed distance matrix '{name}' "
-                                 "must be a binomial coefficient, i.e."
-                                 "there must be a k such that (k \\choose 2)=n)!")
-            else:
-                raise ValueError('Length n of condensed distance matrix must '
-                                 'be a binomial coefficient, i.e. there must '
-                                 'be a k such that (k \\choose 2)=n)!')
+            raise ValueError(f"Length n of condensed distance matrix {name_str}"
+                             "must be a binomial coefficient, i.e. "
+                             "there must be a k such that (k \\choose 2)=n)!")
     except Exception as e:
         if throw:
             raise
         if warning:
             warnings.warn(str(e), stacklevel=2)
-        valid = False
-    return valid
+        return False
+    return True
 
 
 def num_obs_dm(d):
@@ -2735,7 +2742,7 @@ def num_obs_y(Y):
     >>> num_obs_y(Y)
     4
     """
-    Y = np.asarray(Y, order='c')
+    Y = _asarray(Y)
     is_valid_y(Y, throw=True, name='Y')
     k = Y.shape[0]
     if k == 0:

scipy/spatial/tests/test_distance.py

@@ -63,6 +63,7 @@ from scipy.spatial.distance import (braycurtis, canberra, chebyshev, cityblock,
                                     russellrao, seuclidean, sokalmichener,  # noqa: F401
                                     sokalsneath, sqeuclidean, yule)
 from scipy._lib._util import np_long, np_ulong
+from scipy.conftest import skip_xp_invalid_arg
 
 
 @pytest.fixture(params=_METRICS_NAMES, scope="session")
@@ -1370,6 +1371,7 @@ class TestPdist:
         right_y = 0.01492537
         assert_allclose(pdist_y, right_y, atol=eps, verbose=verbose > 2)
 
+    @skip_xp_invalid_arg
     def test_pdist_custom_notdouble(self):
         # tests that when using a custom metric the data type is not altered
         class myclass:
@@ -2106,7 +2108,7 @@ def test_Xdist_deprecated_args(metric):
         pdist(X1, metric, 2.)
 
     for arg in ["p", "V", "VI"]:
-        kwargs = {arg: "foo"}
+        kwargs = {arg: np.asarray(1.)}
 
         if ((arg == "V" and metric == "seuclidean")
                 or (arg == "VI" and metric == "mahalanobis")
@@ -2229,6 +2231,18 @@ def test_immutable_input(metric):
         getattr(scipy.spatial.distance, metric)(x, x, w=x)
 
 
+def test_gh_23109():
+    a = np.array([0, 0, 1, 1])
+    b = np.array([0, 1, 1, 0])
+    w = np.asarray([1.5, 1.2, 0.7, 1.3])
+    expected = yule(a, b, w=w)
+    assert_allclose(expected, 1.1954022988505748)
+    actual = cdist(np.atleast_2d(a),
+                   np.atleast_2d(b),
+                   metric='yule', w=w)
+    assert_allclose(actual, expected)
+
+
 class TestJaccard:
 
     def test_pdist_jaccard_random(self):

scipy/spatial/tests/test_kdtree.py

@@ -426,6 +426,7 @@ def test_random_ball_vectorized(kdtree_type):
     assert_(isinstance(r[0, 0], list))
 
 
+@pytest.mark.fail_slow(5)
 def test_query_ball_point_multithreading(kdtree_type):
     np.random.seed(0)
     n = 5000

scipy/spatial/tests/test_qhull.py

@@ -111,7 +111,7 @@ def _add_inc_data(name, chunksize):
     for j in range(nmin, len(points), chunksize):
         chunks.append(points[j:j+chunksize])
 
-    new_name = "%s-chunk-%d" % (name, chunksize)
+    new_name = f"{name}-chunk-{chunksize}"
     assert new_name not in INCREMENTAL_DATASETS
     INCREMENTAL_DATASETS[new_name] = (chunks, opts)
 
@@ -362,7 +362,7 @@ class TestUtilities:
                 list(map(np.ravel, np.broadcast_arrays(*np.ix_(*([x]*ndim)))))
             ].T
 
-            err_msg = "ndim=%d" % ndim
+            err_msg = f"ndim={ndim}"
 
             # Check using regular grid
             tri = qhull.Delaunay(grid)
@@ -428,6 +428,10 @@ class TestDelaunay:
         masked_array = np.ma.masked_all(1)
         assert_raises(ValueError, qhull.Delaunay, masked_array)
 
+    # Shouldn't be inherently unsafe; retry with cpython 3.14 once traceback
+    # thread safety issues are fixed (also goes for other test with same name
+    # further down)
+    @pytest.mark.thread_unsafe
     def test_array_with_nans_fails(self):
         points_with_nan = np.array([(0,0), (0,1), (1,1), (1,np.nan)], dtype=np.float64)
         assert_raises(ValueError, qhull.Delaunay, points_with_nan)
@@ -607,6 +611,7 @@ class TestConvexHull:
         masked_array = np.ma.masked_all(1)
         assert_raises(ValueError, qhull.ConvexHull, masked_array)
 
+    @pytest.mark.thread_unsafe
     def test_array_with_nans_fails(self):
         points_with_nan = np.array([(0,0), (1,1), (2,np.nan)], dtype=np.float64)
         assert_raises(ValueError, qhull.ConvexHull, points_with_nan)

scipy/spatial/transform/__init__.py

@@ -4,25 +4,27 @@ Spatial Transformations (:mod:`scipy.spatial.transform`)
 
 .. currentmodule:: scipy.spatial.transform
 
-This package implements various spatial transformations. For now,
-only rotations are supported.
+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 ._rigid_transform import RigidTransform
 from ._rotation import Rotation, Slerp
 from ._rotation_spline import RotationSpline
 
 # Deprecated namespaces, to be removed in v2.0.0
 from . import rotation
 
-__all__ = ['Rotation', 'Slerp', 'RotationSpline']
+__all__ = ['Rotation', 'Slerp', 'RotationSpline', 'RigidTransform']
 
 from scipy._lib._testutils import PytestTester
 test = PytestTester(__name__)