scipy 1.15.2__cp311-cp311-macosx_12_0_arm64.whl → 1.16.0__cp311-cp311-macosx_12_0_arm64.whl

scipy/optimize/tests/test_bracket.py

@@ -7,9 +7,8 @@ from scipy.optimize.elementwise import bracket_root, bracket_minimum
 import scipy._lib._elementwise_iterative_method as eim
 from scipy import stats
 from scipy._lib._array_api_no_0d import (xp_assert_close, xp_assert_equal,
-                                         xp_assert_less, array_namespace)
+                                         xp_assert_less)
 from scipy._lib._array_api import xp_ravel
-from scipy.conftest import array_api_compatible
 
 
 # These tests were originally written for the private `optimize._bracket`
@@ -42,12 +41,11 @@ def _bracket_minimum(*args, **kwargs):
 
 
 array_api_strict_skip_reason = 'Array API does not support fancy indexing assignment.'
-jax_skip_reason = 'JAX arrays do not support item assignment.'
+boolean_index_skip_reason = 'JAX/Dask arrays do not support boolean assignment.'
 
 @pytest.mark.skip_xp_backends('array_api_strict', reason=array_api_strict_skip_reason)
-@pytest.mark.skip_xp_backends('jax.numpy', reason=jax_skip_reason)
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
+@pytest.mark.skip_xp_backends('jax.numpy', reason=boolean_index_skip_reason)
+@pytest.mark.skip_xp_backends('dask.array', reason=boolean_index_skip_reason)
 class TestBracketRoot:
     @pytest.mark.parametrize("seed", (615655101, 3141866013, 238075752))
     @pytest.mark.parametrize("use_xmin", (False, True))
@@ -179,10 +177,9 @@ class TestBracketRoot:
             ref_attr = [xp.asarray(getattr(ref, attr)) for ref in refs]
             res_attr = getattr(res, attr)
             xp_assert_close(xp_ravel(res_attr, xp=xp), xp.stack(ref_attr))
-            xp_assert_equal(res_attr.shape, shape)
+            assert res_attr.shape == shape
 
-        xp_test = array_namespace(xp.asarray(1.))
-        assert res.success.dtype == xp_test.bool
+        assert res.success.dtype == xp.bool
         if shape:
             assert xp.all(res.success[1:-1])
         assert res.status.dtype == xp.int32
@@ -229,13 +226,11 @@ class TestBracketRoot:
     def test_dtype(self, root, xmin, xmax, dtype, xp):
         # Test that dtypes are preserved
         dtype = getattr(xp, dtype)
-        xp_test = array_namespace(xp.asarray(1.))
-
         xmin = xmin if xmin is None else xp.asarray(xmin, dtype=dtype)
         xmax = xmax if xmax is None else xp.asarray(xmax, dtype=dtype)
         root = xp.asarray(root, dtype=dtype)
         def f(x, root):
-            return xp_test.astype((x - root) ** 3, dtype)
+            return xp.astype((x - root) ** 3, dtype)
 
         bracket = xp.asarray([-0.01, 0.01], dtype=dtype)
         res = _bracket_root(f, *bracket, xmin=xmin, xmax=xmax, args=(root,))
@@ -254,13 +249,13 @@ class TestBracketRoot:
         with pytest.raises(ValueError, match=message):
             _bracket_root(lambda x: x, -4+1j, 4)
         with pytest.raises(ValueError, match=message):
-            _bracket_root(lambda x: x, -4, 'hello')
+            _bracket_root(lambda x: x, -4, 4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_root(lambda x: x, -4, 4, xmin=np)
+            _bracket_root(lambda x: x, -4, 4, xmin=4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_root(lambda x: x, -4, 4, xmax=object())
+            _bracket_root(lambda x: x, -4, 4, xmax=4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_root(lambda x: x, -4, 4, factor=sum)
+            _bracket_root(lambda x: x, -4, 4, factor=4+1j)
 
         message = "All elements of `factor` must be greater than 1."
         with pytest.raises(ValueError, match=message):
@@ -284,12 +279,10 @@ class TestBracketRoot:
 
     def test_special_cases(self, xp):
         # Test edge cases and other special cases
-        xp_test = array_namespace(xp.asarray(1.))
-
         # Test that integers are not passed to `f`
         # (otherwise this would overflow)
         def f(x):
-            assert xp_test.isdtype(x.dtype, "real floating")
+            assert xp.isdtype(x.dtype, "real floating")
             return x ** 99 - 1
 
         res = _bracket_root(f, xp.asarray(-7.), xp.asarray(5.))
@@ -328,7 +321,7 @@ class TestBracketRoot:
 
         # 2. bracket endpoint hits root exactly
         f.count = 0
-        res = _bracket_root(f, xp.asarray(5.), xp.asarray(10.), 
+        res = _bracket_root(f, xp.asarray(5.), xp.asarray(10.),
                             factor=2)
 
         assert res.nfev == 4
@@ -337,12 +330,12 @@ class TestBracketRoot:
 
         # 3. bracket limit hits root exactly
         with np.errstate(over='ignore'):
-            res = _bracket_root(f, xp.asarray(5.), xp.asarray(10.), 
+            res = _bracket_root(f, xp.asarray(5.), xp.asarray(10.),
                                 xmin=0)
         xp_assert_close(res.xl, xp.asarray(0.), atol=1e-15)
 
         with np.errstate(over='ignore'):
-            res = _bracket_root(f, xp.asarray(-10.), xp.asarray(-5.), 
+            res = _bracket_root(f, xp.asarray(-10.), xp.asarray(-5.),
                                 xmax=0)
         xp_assert_close(res.xr, xp.asarray(0.), atol=1e-15)
 
@@ -352,11 +345,46 @@ class TestBracketRoot:
                                 xmin=1)
         assert not res.success
 
+    def test_bug_fixes(self):
+        # 1. Bug in double sided bracket search.
+        # Happened in some cases where there are terminations on one side
+        # after corresponding searches on other side failed due to reaching the
+        # boundary.
+
+        # https://github.com/scipy/scipy/pull/22560#discussion_r1962853839
+        def f(x, p):
+            return np.exp(x) - p
+
+        p = np.asarray([0.29, 0.35])
+        res = _bracket_root(f, xl0=-1, xmin=-np.inf, xmax=0, args=(p, ))
+
+        # https://github.com/scipy/scipy/pull/22560/files#r1962952517
+        def f(x, p, c):
+            return np.exp(x*c) - p
+
+        p = [0.32061201, 0.39175242, 0.40047535, 0.50527218, 0.55654373,
+             0.11911647, 0.37507896, 0.66554191]
+        c = [1., -1., 1., 1., -1., 1., 1., 1.]
+        xl0 = [-7.63108551,  3.27840947, -8.36968526, -1.78124372,
+               0.92201295, -2.48930123, -0.66733533, -0.44606749]
+        xr0 = [-6.63108551,  4.27840947, -7.36968526, -0.78124372,
+               1.92201295, -1.48930123, 0., 0.]
+        xmin = [-np.inf, 0., -np.inf, -np.inf, 0., -np.inf, -np.inf,
+                -np.inf]
+        xmax = [0., np.inf, 0., 0., np.inf, 0., 0., 0.]
+
+        res = _bracket_root(f, xl0=xl0, xr0=xr0, xmin=xmin, xmax=xmax, args=(p, c))
+
+        # 2. Default xl0 + 1 for xr0 exceeds xmax.
+        # https://github.com/scipy/scipy/pull/22560#discussion_r1962947434
+        res = _bracket_root(lambda x: x + 0.25, xl0=-0.5, xmin=-np.inf, xmax=0)
+        assert res.success
 
+
+@pytest.mark.skip_xp_backends('torch', reason='data-apis/array-api-compat#271')
 @pytest.mark.skip_xp_backends('array_api_strict', reason=array_api_strict_skip_reason)
-@pytest.mark.skip_xp_backends('jax.numpy', reason=jax_skip_reason)
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
+@pytest.mark.skip_xp_backends('jax.numpy', reason=boolean_index_skip_reason)
+@pytest.mark.skip_xp_backends('dask.array', reason=boolean_index_skip_reason)
 class TestBracketMinimum:
     def init_f(self):
         def f(x, a, b):
@@ -471,10 +499,10 @@ class TestBracketMinimum:
             funcs = [lambda x: (x - 1.5)**2,
                      lambda x: x,
                      lambda x: x,
-                     lambda x: xp.nan,
+                     lambda x: xp.asarray(xp.nan),
                      lambda x: x**2]
 
-            return [funcs[j](x) for x, j in zip(xs, js)]
+            return [funcs[int(j)](x) for x, j in zip(xs, js)]
 
         args = (xp.arange(5, dtype=xp.int64),)
         xl0 = xp.asarray([-1.0, -1.0, -1.0, -1.0, 6.0])
@@ -496,13 +524,12 @@ class TestBracketMinimum:
     @pytest.mark.parametrize("xmax", [5, None])
     def test_dtypes(self, minimum, xmin, xmax, dtype, xp):
         dtype = getattr(xp, dtype)
-        xp_test = array_namespace(xp.asarray(1.))
         xmin = xmin if xmin is None else xp.asarray(xmin, dtype=dtype)
         xmax = xmax if xmax is None else xp.asarray(xmax, dtype=dtype)
         minimum = xp.asarray(minimum, dtype=dtype)
 
         def f(x, minimum):
-            return xp_test.astype((x - minimum)**2, dtype)
+            return xp.astype((x - minimum)**2, dtype)
 
         xl0, xm0, xr0 = [-0.01, 0.0, 0.01]
         result = _bracket_minimum(
@@ -525,23 +552,21 @@ class TestBracketMinimum:
         with pytest.raises(ValueError, match=message):
             _bracket_minimum(lambda x: x**2, xp.asarray(4+1j))
         with pytest.raises(ValueError, match=message):
-            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xl0='hello')
+            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xl0=4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_minimum(lambda x: x**2, xp.asarray(-4),
-                             xr0='farcical aquatic ceremony')
+            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xr0=4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xmin=np)
+            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xmin=4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xmax=object())
+            _bracket_minimum(lambda x: x**2, xp.asarray(-4), xmax=4+1j)
         with pytest.raises(ValueError, match=message):
-            _bracket_minimum(lambda x: x**2, xp.asarray(-4), factor=sum)
+            _bracket_minimum(lambda x: x**2, xp.asarray(-4), factor=4+1j)
 
         message = "All elements of `factor` must be greater than 1."
         with pytest.raises(ValueError, match=message):
             _bracket_minimum(lambda x: x, xp.asarray(-4), factor=0.5)
 
-        message = "shape mismatch: objects cannot be broadcast"
-        # raised by `xp.broadcast, but the traceback is readable IMO
+        message = "Array shapes are incompatible for broadcasting."
         with pytest.raises(ValueError, match=message):
             _bracket_minimum(lambda x: x**2, xp.asarray([-2, -3]), xl0=[-3, -4, -5])
 
@@ -776,18 +801,19 @@ class TestBracketMinimum:
         factor = rng.random(size=shape) + 1.5
         refs = bracket_minimum_single(xm0, xl0, xr0, xmin, xmax, factor, a).ravel()
         args = tuple(xp.asarray(arg, dtype=xp.float64) for arg in args)
-        res = _bracket_minimum(f, xp.asarray(xm0), xl0=xl0, xr0=xr0, xmin=xmin,
-                               xmax=xmax, factor=factor, args=args, maxiter=maxiter)
+        res = _bracket_minimum(f, xp.asarray(xm0), xl0=xp.asarray(xl0),
+                               xr0=xp.asarray(xr0), xmin=xp.asarray(xmin),
+                               xmax=xp.asarray(xmax), factor=xp.asarray(factor),
+                               args=args, maxiter=maxiter)
 
         attrs = ['xl', 'xm', 'xr', 'fl', 'fm', 'fr', 'success', 'nfev', 'nit']
         for attr in attrs:
             ref_attr = [xp.asarray(getattr(ref, attr)) for ref in refs]
             res_attr = getattr(res, attr)
             xp_assert_close(xp_ravel(res_attr, xp=xp), xp.stack(ref_attr))
-            xp_assert_equal(res_attr.shape, shape)
+            assert res_attr.shape == shape
 
-        xp_test = array_namespace(xp.asarray(1.))
-        assert res.success.dtype == xp_test.bool
+        assert res.success.dtype == xp.bool
         if shape:
             assert xp.all(res.success[1:-1])
         assert res.status.dtype == xp.int32
@@ -801,12 +827,11 @@ class TestBracketMinimum:
 
     def test_special_cases(self, xp):
         # Test edge cases and other special cases.
-        xp_test = array_namespace(xp.asarray(1.))
 
         # Test that integers are not passed to `f`
         # (otherwise this would overflow)
         def f(x):
-            assert xp_test.isdtype(x.dtype, "numeric")
+            assert xp.isdtype(x.dtype, "numeric")
             return x ** 98 - 1
 
         result = _bracket_minimum(f, xp.asarray(-7., dtype=xp.float64), xr0=5)
@@ -855,7 +880,7 @@ class TestBracketMinimum:
 
         result = _bracket_minimum(f, xp.asarray(0.5535723499480897), xmin=xmin,
                                   xmax=xmax)
-        assert xmin == result.xl
+        xp_assert_close(result.xl, xmin)
 
     def test_gh_20562_right(self, xp):
         # Regression test for https://github.com/scipy/scipy/issues/20562
@@ -868,4 +893,4 @@ class TestBracketMinimum:
 
         result = _bracket_minimum(f, xp.asarray(-0.5535723499480897),
                                   xmin=xmin, xmax=xmax)
-        assert xmax == result.xr
+        xp_assert_close(result.xr, xmax)