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

scipy/sparse/construct.py

@@ -9,10 +9,8 @@ __all__ = [  # noqa: F822
     'block_diag',
     'bmat',
     'bsr_matrix',
-    'check_random_state',
     'coo_matrix',
     'csc_matrix',
-    'csr_hstack',
     'csr_matrix',
     'dia_matrix',
     'diags',
@@ -20,16 +18,12 @@ __all__ = [  # noqa: F822
     'get_index_dtype',
     'hstack',
     'identity',
-    'isscalarlike',
     'issparse',
     'kron',
     'kronsum',
-    'numbers',
     'rand',
     'random',
-    'rng_integers',
     'spdiags',
-    'upcast',
     'vstack',
 ]
 

scipy/sparse/coo.py

@@ -7,23 +7,9 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 __all__ = [  # noqa: F822
     'SparseEfficiencyWarning',
-    'check_reshape_kwargs',
-    'check_shape',
     'coo_matrix',
-    'coo_matvec',
-    'coo_tocsr',
-    'coo_todense',
-    'downcast_intp_index',
-    'getdata',
-    'getdtype',
-    'isshape',
     'isspmatrix_coo',
-    'operator',
     'spmatrix',
-    'to_native',
-    'upcast',
-    'upcast_char',
-    'warn',
 ]
 
 

scipy/sparse/csc.py

@@ -7,11 +7,8 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 __all__ = [  # noqa: F822
     'csc_matrix',
-    'csc_tocsr',
-    'expandptr',
     'isspmatrix_csc',
     'spmatrix',
-    'upcast',
 ]
 
 

scipy/sparse/csgraph/tests/test_matching.py

@@ -4,7 +4,7 @@ import numpy as np
 from numpy.testing import assert_array_equal, assert_equal
 import pytest
 
-from scipy.sparse import csr_array, diags_array
+from scipy.sparse import csr_array, coo_array, diags_array
 from scipy.sparse.csgraph import (
     maximum_bipartite_matching, min_weight_full_bipartite_matching
 )
@@ -152,10 +152,16 @@ def test_matching_large_random_graph_with_one_edge_incident_to_each_vertex():
 @pytest.mark.parametrize('num_rows,num_cols', [(0, 0), (2, 0), (0, 3)])
 def test_min_weight_full_matching_trivial_graph(num_rows, num_cols):
     biadjacency = csr_array((num_cols, num_rows))
+    biadjacency1 = coo_array((num_cols, num_rows))
+
     row_ind, col_ind = min_weight_full_bipartite_matching(biadjacency)
     assert len(row_ind) == 0
     assert len(col_ind) == 0
 
+    row_ind1, col_ind1 = min_weight_full_bipartite_matching(biadjacency1)
+    assert len(row_ind1) == 0
+    assert len(col_ind1) == 0
+
 
 @pytest.mark.parametrize('biadjacency',
                          [
@@ -169,6 +175,8 @@ def test_min_weight_full_matching_trivial_graph(num_rows, num_cols):
 def test_min_weight_full_matching_infeasible_problems(biadjacency):
     with pytest.raises(ValueError):
         min_weight_full_bipartite_matching(csr_array(biadjacency))
+    with pytest.raises(ValueError):
+        min_weight_full_bipartite_matching(coo_array(biadjacency))
 
 
 def test_min_weight_full_matching_large_infeasible():
@@ -223,13 +231,17 @@ def test_min_weight_full_matching_large_infeasible():
         ])
     with pytest.raises(ValueError, match='no full matching exists'):
         min_weight_full_bipartite_matching(csr_array(a))
+    with pytest.raises(ValueError, match='no full matching exists'):
+        min_weight_full_bipartite_matching(coo_array(a))
 
 
 @pytest.mark.thread_unsafe
 def test_explicit_zero_causes_warning():
+    biadjacency = csr_array(((2, 0, 3), (0, 1, 1), (0, 2, 3)))
     with pytest.warns(UserWarning):
-        biadjacency = csr_array(((2, 0, 3), (0, 1, 1), (0, 2, 3)))
         min_weight_full_bipartite_matching(biadjacency)
+    with pytest.warns(UserWarning):
+        min_weight_full_bipartite_matching(biadjacency.tocoo())
 
 
 # General test for linear sum assignment solvers to make it possible to rely

scipy/sparse/csgraph/tests/test_pydata_sparse.py

@@ -154,9 +154,12 @@ def test_min_weight_full_bipartite_matching(graphs):
     func = spgraph.min_weight_full_bipartite_matching
 
     actual = func(A_sparse[0:2, 1:3])
-    desired = func(sp.csc_array(A_dense)[0:2, 1:3])
+    A_csc = sp.csc_array(A_dense)
+    desired = func(A_csc[0:2, 1:3])
+    desired1 = func(A_csc[0:2, 1:3].tocoo())
 
     assert_equal(actual, desired)
+    assert_equal(actual, desired1)
 
 
 @check_sparse_version("0.15.4")

scipy/sparse/csgraph/tests/test_shortest_path.py

@@ -16,6 +16,7 @@ directed_G = np.array([[0, 3, 3, 0, 0],
                        [1, 0, 0, 0, 0],
                        [2, 0, 0, 2, 0]], dtype=float)
 
+# Undirected version of directed_G
 undirected_G = np.array([[0, 3, 3, 1, 2],
                          [3, 0, 0, 2, 4],
                          [3, 0, 0, 0, 0],
@@ -24,6 +25,7 @@ undirected_G = np.array([[0, 3, 3, 1, 2],
 
 unweighted_G = (directed_G > 0).astype(float)
 
+# Correct shortest path lengths for directed_G and undirected_G
 directed_SP = [[0, 3, 3, 5, 7],
                [3, 0, 6, 2, 4],
                [np.inf, np.inf, 0, np.inf, np.inf],
@@ -33,6 +35,35 @@ directed_SP = [[0, 3, 3, 5, 7],
 directed_2SP_0_to_3 = [[-9999, 0, -9999, 1, -9999],
                        [-9999, 0, -9999, 4, 1]]
 
+undirected_SP = np.array([[0, 3, 3, 1, 2],
+                          [3, 0, 6, 2, 4],
+                          [3, 6, 0, 4, 5],
+                          [1, 2, 4, 0, 2],
+                          [2, 4, 5, 2, 0]], dtype=float)
+
+undirected_SP_limit_2 = np.array([[0, np.inf, np.inf, 1, 2],
+                                  [np.inf, 0, np.inf, 2, np.inf],
+                                  [np.inf, np.inf, 0, np.inf, np.inf],
+                                  [1, 2, np.inf, 0, 2],
+                                  [2, np.inf, np.inf, 2, 0]], dtype=float)
+
+undirected_SP_limit_0 = np.ones((5, 5), dtype=float) - np.eye(5)
+undirected_SP_limit_0[undirected_SP_limit_0 > 0] = np.inf
+
+# Correct predecessors for directed_G and undirected_G
+directed_pred = np.array([[-9999, 0, 0, 1, 1],
+                          [3, -9999, 0, 1, 1],
+                          [-9999, -9999, -9999, -9999, -9999],
+                          [3, 0, 0, -9999, 1],
+                          [4, 0, 0, 4, -9999]], dtype=float)
+
+undirected_pred = np.array([[-9999, 0, 0, 0, 0],
+                            [1, -9999, 0, 1, 1],
+                            [2, 0, -9999, 0, 0],
+                            [3, 3, 0, -9999, 3],
+                            [4, 4, 0, 4, -9999]], dtype=float)
+
+# Other graphs
 directed_sparse_zero_G = scipy.sparse.csr_array(
     (
         [0, 1, 2, 3, 1],
@@ -61,33 +92,6 @@ undirected_sparse_zero_SP = [[0, 0, 1, np.inf, np.inf],
                         [np.inf, np.inf, np.inf, 0, 1],
                         [np.inf, np.inf, np.inf, 1, 0]]
 
-directed_pred = np.array([[-9999, 0, 0, 1, 1],
-                          [3, -9999, 0, 1, 1],
-                          [-9999, -9999, -9999, -9999, -9999],
-                          [3, 0, 0, -9999, 1],
-                          [4, 0, 0, 4, -9999]], dtype=float)
-
-undirected_SP = np.array([[0, 3, 3, 1, 2],
-                          [3, 0, 6, 2, 4],
-                          [3, 6, 0, 4, 5],
-                          [1, 2, 4, 0, 2],
-                          [2, 4, 5, 2, 0]], dtype=float)
-
-undirected_SP_limit_2 = np.array([[0, np.inf, np.inf, 1, 2],
-                                  [np.inf, 0, np.inf, 2, np.inf],
-                                  [np.inf, np.inf, 0, np.inf, np.inf],
-                                  [1, 2, np.inf, 0, 2],
-                                  [2, np.inf, np.inf, 2, 0]], dtype=float)
-
-undirected_SP_limit_0 = np.ones((5, 5), dtype=float) - np.eye(5)
-undirected_SP_limit_0[undirected_SP_limit_0 > 0] = np.inf
-
-undirected_pred = np.array([[-9999, 0, 0, 0, 0],
-                            [1, -9999, 0, 1, 1],
-                            [2, 0, -9999, 0, 0],
-                            [3, 3, 0, -9999, 3],
-                            [4, 4, 0, 4, -9999]], dtype=float)
-
 directed_negative_weighted_G = np.array([[0, 0, 0],
                                          [-1, 0, 0],
                                          [0, -1, 0]], dtype=float)
@@ -217,6 +221,28 @@ def test_dijkstra_min_only_random(n):
             p = pred[p]
 
 
+@pytest.mark.parametrize('n', (10, 100))
+@pytest.mark.parametrize("method", ['FW', 'J', 'BF'])
+@pytest.mark.parametrize('directed', (True, False))
+def test_star_graph(n, method, directed):
+    # Build the star graph
+    star_arr = np.zeros((n, n), dtype=float)
+    star_center_idx = 0
+    star_arr[star_center_idx, :] = star_arr[:, star_center_idx] = range(n)
+    G = scipy.sparse.csr_matrix(star_arr, shape=(n, n))
+    # Build the distances matrix
+    SP_solution = np.zeros((n, n), dtype=float)
+    SP_solution[:] = star_arr[star_center_idx]
+    for idx in range(1, n):
+        SP_solution[idx] += star_arr[idx, star_center_idx]
+    np.fill_diagonal(SP_solution, 0)
+
+    SP = shortest_path(G, method=method, directed=directed)
+    assert_allclose(
+        SP_solution, SP
+    )
+
+
 def test_dijkstra_random():
     # reproduces the hang observed in gh-17782
     n = 10
@@ -307,6 +333,15 @@ def test_construct_shortest_path():
         for directed in (True, False):
             check(method, directed)
 
+@pytest.mark.parametrize("directed", [True, False])
+def test_construct_dist_matrix_predecessors_error(directed):
+    SP1, pred = shortest_path(directed_G,
+                                directed=directed,
+                                overwrite=False,
+                                return_predecessors=True)
+    assert_raises(TypeError, construct_dist_matrix,
+                  directed_G, pred.astype(np.int64), directed)
+
 
 def test_unweighted_path():
     def check(method, directed):
@@ -419,15 +454,34 @@ def test_yen_directed():
     assert_allclose(predecessors, directed_2SP_0_to_3)
 
 
+def test_yen_dense():
+    dense_undirected_G = np.array([
+                       [0, 3, 3, 1, 2],
+                       [3, 0, 7, 6, 5],
+                       [3, 7, 0, 4, 0],
+                       [1, 6, 4, 0, 2],
+                       [2, 5, 0, 2, 0]], dtype=float)
+    distances = yen(
+                dense_undirected_G,
+                source=0,
+                sink=4,
+                K=5,
+                directed=False,
+            )
+    assert_allclose(distances, [2., 3., 8., 9., 11.])
+
+
 def test_yen_undirected():
     distances = yen(
         undirected_G,
         source=0,
         sink=3,
         K=4,
+        directed=False,
     )
     assert_allclose(distances, [1., 4., 5., 8.])
 
+
 def test_yen_unweighted():
     # Ask for more paths than there are, verify only the available paths are returned
     distances, predecessors = yen(
@@ -441,6 +495,7 @@ def test_yen_unweighted():
     assert_allclose(distances, [2., 3.])
     assert_allclose(predecessors, directed_2SP_0_to_3)
 
+
 def test_yen_no_paths():
     distances = yen(
         directed_G,
@@ -450,6 +505,7 @@ def test_yen_no_paths():
     )
     assert distances.size == 0
 
+
 def test_yen_negative_weights():
     distances = yen(
         directed_negative_weighted_G,

scipy/sparse/csr.py

@@ -6,14 +6,9 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'csr_count_blocks',
     'csr_matrix',
-    'csr_tobsr',
-    'csr_tocsc',
-    'get_csr_submatrix',
     'isspmatrix_csr',
     'spmatrix',
-    'upcast',
 ]
 
 

scipy/sparse/data.py

@@ -5,12 +5,7 @@
 from scipy._lib.deprecation import _sub_module_deprecation
 
 
-__all__ = [  # noqa: F822
-    'isscalarlike',
-    'name',
-    'npfunc',
-    'validateaxis',
-]
+__all__ : list[str] = []
 
 
 def __dir__():

scipy/sparse/dia.py

@@ -6,16 +6,9 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'check_shape',
     'dia_matrix',
-    'dia_matvec',
-    'get_sum_dtype',
-    'getdtype',
-    'isshape',
     'isspmatrix_dia',
     'spmatrix',
-    'upcast_char',
-    'validateaxis',
 ]
 
 

scipy/sparse/dok.py

@@ -6,19 +6,9 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'IndexMixin',
-    'check_shape',
     'dok_matrix',
-    'getdtype',
-    'isdense',
-    'isintlike',
-    'isscalarlike',
-    'isshape',
     'isspmatrix_dok',
-    'itertools',
     'spmatrix',
-    'upcast',
-    'upcast_scalar',
 ]
 
 

scipy/sparse/linalg/_dsolve/linsolve.py

@@ -26,6 +26,7 @@ __all__ = ['use_solver', 'spsolve', 'splu', 'spilu', 'factorized',
 
 
 class MatrixRankWarning(UserWarning):
+    """Warning for exactly singular matrices."""
     pass
 
 
@@ -371,6 +372,10 @@ def splu(A, permc_spec=None, diag_pivot_thresh=None,
 
     Notes
     -----
+    When a real array is factorized and the returned SuperLU object's ``solve()``
+    method is used with complex arguments an error is generated. Instead, cast the
+    initial array to complex and then factorize.
+
     This function uses the SuperLU library.
 
     References
@@ -468,6 +473,10 @@ def spilu(A, drop_tol=None, fill_factor=None, drop_rule=None, permc_spec=None,
 
     Notes
     -----
+    When a real array is factorized and the returned SuperLU object's ``solve()`` method
+    is used with complex arguments an error is generated. Instead, cast the initial 
+    array to complex and then factorize.
+
     To improve the better approximation to the inverse, you may need to
     increase `fill_factor` AND decrease `drop_tol`.
 

scipy/sparse/linalg/_dsolve/tests/test_linsolve.py

@@ -3,7 +3,7 @@ import threading
 
 import numpy as np
 from numpy import array, finfo, arange, eye, all, unique, ones, dot
-import numpy.random as random
+from numpy.exceptions import ComplexWarning
 from numpy.testing import (
         assert_array_almost_equal, assert_almost_equal,
         assert_equal, assert_array_equal, assert_, assert_allclose,
@@ -22,7 +22,6 @@ from scipy.sparse.linalg._dsolve import (spsolve, use_solver, splu, spilu,
 import scipy.sparse
 
 from scipy._lib._testutils import check_free_memory
-from scipy._lib._util import ComplexWarning
 
 
 sup_sparse_efficiency = suppress_warnings()
@@ -61,7 +60,6 @@ class TestFactorized:
         d = arange(n) + 1
         self.n = n
         self.A = dia_array(((d, 2*d, d[::-1]), (-3, 0, 5)), shape=(n,n)).tocsc()
-        random.seed(1234)
 
     def _check_singular(self):
         A = csc_array((5,5), dtype='d')
@@ -71,7 +69,8 @@ class TestFactorized:
     def _check_non_singular(self):
         # Make a diagonal dominant, to make sure it is not singular
         n = 5
-        a = csc_array(random.rand(n, n))
+        rng = np.random.default_rng(14332)
+        a = csc_array(rng.random((n, n)))
         b = ones(n)
 
         expected = splu(a).solve(b)
@@ -113,9 +112,11 @@ class TestFactorized:
     def test_call_with_incorrectly_sized_matrix_without_umfpack(self):
         use_solver(useUmfpack=False)
         solve = factorized(self.A)
-        b = random.rand(4)
-        B = random.rand(4, 3)
-        BB = random.rand(self.n, 3, 9)
+
+        rng = np.random.default_rng(230498)
+        b = rng.random(4)
+        B = rng.random((4, 3))
+        BB = rng.random((self.n, 3, 9))
 
         with assert_raises(ValueError, match="is of incompatible size"):
             solve(b)
@@ -129,9 +130,11 @@ class TestFactorized:
     def test_call_with_incorrectly_sized_matrix_with_umfpack(self):
         use_solver(useUmfpack=True)
         solve = factorized(self.A)
-        b = random.rand(4)
-        B = random.rand(4, 3)
-        BB = random.rand(self.n, 3, 9)
+
+        rng = np.random.default_rng(643095823)
+        b = rng.random(4)
+        B = rng.random((4, 3))
+        BB = rng.random((self.n, 3, 9))
 
         # does not raise
         solve(b)
@@ -144,7 +147,8 @@ class TestFactorized:
     def test_call_with_cast_to_complex_without_umfpack(self):
         use_solver(useUmfpack=False)
         solve = factorized(self.A)
-        b = random.rand(4)
+        rng = np.random.default_rng(23454)
+        b = rng.random(4)
         for t in [np.complex64, np.complex128]:
             with assert_raises(TypeError, match="Cannot cast array data"):
                 solve(b.astype(t))
@@ -153,7 +157,8 @@ class TestFactorized:
     def test_call_with_cast_to_complex_with_umfpack(self):
         use_solver(useUmfpack=True)
         solve = factorized(self.A)
-        b = random.rand(4)
+        rng = np.random.default_rng(23454)
+        b = rng.random(4)
         for t in [np.complex64, np.complex128]:
             assert_warns(ComplexWarning, solve, b.astype(t))
 
@@ -246,8 +251,8 @@ class TestLinsolve:
                         [1., 0., 1.],
                         [0., 0., 1.]])
         As = csc_array(Adense)
-        random.seed(1234)
-        x = random.randn(3)
+        rng = np.random.default_rng(1234)
+        x = rng.standard_normal(3)
         b = As@x
         x2 = spsolve(As, b)
 
@@ -258,8 +263,8 @@ class TestLinsolve:
                         [1., 0., 1.],
                         [0., 0., 1.]])
         As = csc_array(Adense)
-        random.seed(1234)
-        x = random.randn(3, 4)
+        rng = np.random.default_rng(1234)
+        x = rng.standard_normal((3, 4))
         Bdense = As.dot(x)
         Bs = csc_array(Bdense)
         x2 = spsolve(As, Bs)
@@ -452,7 +457,6 @@ class TestSplu:
         d = arange(n) + 1
         self.n = n
         self.A = dia_array(((d, 2*d, d[::-1]), (-3, 0, 5)), shape=(n, n)).tocsc()
-        random.seed(1234)
 
     def _smoketest(self, spxlu, check, dtype, idx_dtype):
         if np.issubdtype(dtype, np.complexfloating):
@@ -465,7 +469,7 @@ class TestSplu:
         A.indptr = A.indptr.astype(idx_dtype, copy=False)
         lu = spxlu(A)
 
-        rng = random.RandomState(1234)
+        rng = np.random.RandomState(1234)
 
         # Input shapes
         for k in [None, 1, 2, self.n, self.n+2]:
@@ -552,7 +556,7 @@ class TestSplu:
     def test_splu_basic(self):
         # Test basic splu functionality.
         n = 30
-        rng = random.RandomState(12)
+        rng = np.random.RandomState(12)
         a = rng.rand(n, n)
         a[a < 0.95] = 0
         # First test with a singular matrix
@@ -572,7 +576,8 @@ class TestSplu:
     def test_splu_perm(self):
         # Test the permutation vectors exposed by splu.
         n = 30
-        a = random.random((n, n))
+        rng = np.random.default_rng(1342354)
+        a = rng.random((n, n))
         a[a < 0.95] = 0
         # Make a diagonal dominant, to make sure it is not singular
         a += 4*eye(n)
@@ -621,7 +626,8 @@ class TestSplu:
     def test_lu_refcount(self):
         # Test that we are keeping track of the reference count with splu.
         n = 30
-        a = random.random((n, n))
+        rng = np.random.default_rng(1342354)
+        a = rng.random((n, n))
         a[a < 0.95] = 0
         # Make a diagonal dominant, to make sure it is not singular
         a += 4*eye(n)
@@ -638,14 +644,15 @@ class TestSplu:
 
     def test_bad_inputs(self):
         A = self.A.tocsc()
+        rng = np.random.default_rng(235634)
 
         assert_raises(ValueError, splu, A[:,:4])
         assert_raises(ValueError, spilu, A[:,:4])
 
         for lu in [splu(A), spilu(A)]:
-            b = random.rand(42)
-            B = random.rand(42, 3)
-            BB = random.rand(self.n, 3, 9)
+            b = rng.random(42)
+            B = rng.random((42, 3))
+            BB = rng.random((self.n, 3, 9))
             assert_raises(ValueError, lu.solve, b)
             assert_raises(ValueError, lu.solve, B)
             assert_raises(ValueError, lu.solve, BB)
@@ -877,14 +884,14 @@ class TestSpsolveTriangular:
                 A = A.tocsr(copy=False)
             return A
 
-        np.random.seed(1234)
+        rng = np.random.default_rng(1234)
         A = random_triangle_matrix(n, lower=lower)
         if choice_of_b == "floats":
-            b = np.random.rand(n, m)
+            b = rng.random((n, m))
         elif choice_of_b == "ints":
-            b = np.random.randint(-9, 9, (n, m))
+            b = rng.integers(-9, 9, (n, m))
         elif choice_of_b == "complexints":
-            b = np.random.randint(-9, 9, (n, m)) + np.random.randint(-9, 9, (n, m)) * 1j
+            b = rng.integers(-9, 9, (n, m)) + rng.integers(-9, 9, (n, m)) * 1j
         else:
             raise ValueError(
                 "choice_of_b must be 'floats', 'ints', or 'complexints'.")