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

scipy/linalg/tests/test_decomp_cossin.py

@@ -112,6 +112,20 @@ def test_cossin_error_non_iterable():
     with pytest.raises(ValueError, match="containing the subblocks of X"):
         cossin(12j)
 
+def test_cossin_error_invalid_shape():
+    # Invalid x12 dimensions
+    p, q = 3, 4
+    invalid_x12 = np.ones((p, q + 2))
+    valid_ones = np.ones((p, q))
+    with pytest.raises(ValueError, 
+            match=r"Invalid x12 dimensions: desired \(3, 4\), got \(3, 6\)"):
+        cossin((valid_ones, invalid_x12, valid_ones, valid_ones))
+
+    # Invalid x21 dimensions
+    invalid_x21 = np.ones(p + 2)
+    with pytest.raises(ValueError, 
+            match=r"Invalid x21 dimensions: desired \(3, 4\), got \(1, 5\)"):
+        cossin((valid_ones, valid_ones, invalid_x21, valid_ones))
 
 def test_cossin_error_non_square():
     with pytest.raises(ValueError, match="only supports square"):

scipy/linalg/tests/test_decomp_ldl.py

@@ -2,9 +2,9 @@ from numpy.testing import assert_array_almost_equal, assert_allclose, assert_
 from numpy import (array, eye, zeros, empty_like, empty, tril_indices_from,
                    tril, triu_indices_from, spacing, float32, float64,
                    complex64, complex128)
+from numpy.exceptions import ComplexWarning
 from numpy.random import rand, randint, seed
 from scipy.linalg import ldl
-from scipy._lib._util import ComplexWarning
 import pytest
 from pytest import raises as assert_raises, warns
 

scipy/linalg/tests/test_lapack.py

@@ -19,7 +19,7 @@ from numpy.random import rand, randint, seed
 
 from scipy.linalg import (_flapack as flapack, lapack, inv, svd, cholesky,
                           solve, ldl, norm, block_diag, qr, eigh, qz)
-
+from scipy.linalg._basic import _to_banded
 from scipy.linalg.lapack import _compute_lwork
 from scipy.stats import ortho_group, unitary_group
 
@@ -502,8 +502,10 @@ class TestDlasd4:
             res = lasd4(i, sgm, mvc)
             roots.append(res[1])
 
-            assert_((res[3] <= 0), "LAPACK root finding dlasd4 failed to find \
-                                    the singular value %i" % i)
+            assert_(
+                (res[3] <= 0), 
+                f"LAPACK root finding dlasd4 failed to find the singular value {i}"
+            )
         roots = np.array(roots)[::-1]
 
         assert_((not np.any(np.isnan(roots)), "There are NaN roots"))
@@ -681,7 +683,7 @@ def test_trcon(dtype, norm, uplo, diag, n):
         norm_inv_A = np.linalg.norm(np.linalg.inv(A), ord=np.inf)
         ref = 1 / (norm_A * norm_inv_A)
     else:
-        anorm = np.abs(A).sum(axis=0).max()
+        anorm = np.linalg.norm(A, ord=1)
         gecon, getrf = get_lapack_funcs(('gecon', 'getrf'), (A,))
         lu, ipvt, info = getrf(A)
         ref, _ = gecon(lu, anorm, norm=norm)
@@ -2207,7 +2209,7 @@ def test_gtcon(dtype, norm, n):
         A, d, dl, du = A.real, d.real, dl.real, du.real
     A, d, dl, du = A.astype(dtype), d.astype(dtype), dl.astype(dtype), du.astype(dtype)
 
-    anorm = np.abs(A).sum(axis=0).max()
+    anorm = np.linalg.norm(A, ord=np.inf if norm == 'I' else 1)
 
     gttrf, gtcon = get_lapack_funcs(('gttrf', 'gtcon'), (A,))
     dl, d, du, du2, ipiv, info = gttrf(dl, d, du)
@@ -3479,14 +3481,41 @@ def test_sy_hetrs(mtype, dtype, lower):
     names = f'{mtype}trf', f'{mtype}trf_lwork', f'{mtype}trs'
     trf, trf_lwork, trs = get_lapack_funcs(names, dtype=dtype)
     lwork = trf_lwork(n, lower=lower)
-    ldu, ipiv, info = trf(A, lwork=lwork)
+    ldu, ipiv, info = trf(A, lwork=lwork, lower=lower)
     assert info == 0
-    x, info = trs(a=ldu, ipiv=ipiv, b=b)
+    x, info = trs(a=ldu, ipiv=ipiv, b=b, lower=lower)
     assert info == 0
     eps = np.finfo(dtype).eps
     assert_allclose(A@x, b, atol=100*n*eps)
 
 
+@pytest.mark.parametrize('mtype', ['sy', 'he'])  # matrix type
+@pytest.mark.parametrize('dtype', DTYPES)
+@pytest.mark.parametrize('lower', (0, 1))
+def test_sy_he_tri(dtype, lower, mtype):
+    if mtype == 'he' and dtype in REAL_DTYPES:
+        pytest.skip("hetri not for real dtypes.")
+    rng = np.random.default_rng(1723059677121834)
+    n = 20
+    A = rng.random((n, n)) + rng.random((n, n))*1j
+    if np.issubdtype(dtype, np.floating):
+        A = A.real
+    A = A.astype(dtype)
+    A = A + A.T if mtype == 'sy' else A + A.conj().T
+    names = f'{mtype}trf', f'{mtype}tri'
+    trf, tri = get_lapack_funcs(names, dtype=dtype)
+    ldu, ipiv, info = trf(A, lower=lower)
+    assert info == 0
+    A_inv, info = tri(a=ldu, ipiv=ipiv, lower=lower)
+    assert info == 0
+    eps = np.finfo(dtype).eps
+    ref = np.linalg.inv(A)
+    if lower:
+        assert_allclose(np.tril(A_inv), np.tril(ref), atol=100*n*eps)
+    else:
+        assert_allclose(np.triu(A_inv), np.triu(ref), atol=100*n*eps)
+
+
 @pytest.mark.parametrize('norm', list('Mm1OoIiFfEe'))
 @pytest.mark.parametrize('uplo, m, n', [('U', 5, 10), ('U', 10, 10),
                                         ('L', 10, 5), ('L', 10, 10)])
@@ -3506,3 +3535,82 @@ def test_lantr(norm, uplo, m, n, diag, dtype):
     ref = lange(norm, A)
 
     assert_allclose(res, ref, rtol=2e-6)
+
+
+@pytest.mark.parametrize('dtype', DTYPES)
+@pytest.mark.parametrize('norm', ['1', 'I', 'O'])
+def test_gbcon(dtype, norm):
+    rng = np.random.default_rng(17273783424)
+
+    # A is of shape n x n with ku/kl super/sub-diagonals
+    n, ku, kl = 10, 2, 2
+    A = rng.random((n, n)) + rng.random((n, n))*1j
+    # make the condition numbers more interesting
+    offset = rng.permuted(np.logspace(0, rng.integers(0, 10), n))
+    A += offset
+    if np.issubdtype(dtype, np.floating):
+        A = A.real
+    A = A.astype(dtype)
+    A[np.triu_indices(n, ku + 1)] = 0
+    A[np.tril_indices(n, -kl - 1)] = 0
+
+    # construct banded form
+    tmp = _to_banded(kl, ku, A)
+    # add rows required by ?gbtrf
+    LDAB = 2*kl + ku + 1
+    ab = np.zeros((LDAB, n), dtype=dtype)
+    ab[kl:, :] = tmp
+
+    anorm = np.linalg.norm(A, ord=np.inf if norm == 'I' else 1)
+    gbcon, gbtrf = get_lapack_funcs(("gbcon", "gbtrf"), (ab,))
+    lu_band, ipiv, _ = gbtrf(ab, kl, ku)
+    res = gbcon(norm=norm, kl=kl, ku=ku, ab=lu_band, ipiv=ipiv,
+                anorm=anorm)[0]
+
+    gecon, getrf = get_lapack_funcs(('gecon', 'getrf'), (A,))
+    lu = getrf(A)[0]
+    ref = gecon(lu, anorm, norm=norm)[0]
+    # This is an estimate of reciprocal condition number; we just need order of
+    # magnitude.
+    assert_allclose(res, ref, rtol=1)
+
+
+@pytest.mark.parametrize('norm', list('Mm1OoIiFfEe'))
+@pytest.mark.parametrize('dtype', DTYPES)
+def test_langb(dtype, norm):
+    rng = np.random.default_rng(17273783424)
+
+    # A is of shape n x n with ku/kl super/sub-diagonals
+    n, ku, kl = 10, 2, 2
+    A = rng.random((n, n)) + rng.random((n, n))*1j
+    if np.issubdtype(dtype, np.floating):
+        A = A.real
+    A = A.astype(dtype)
+    A[np.triu_indices(n, ku + 1)] = 0
+    A[np.tril_indices(n, -kl - 1)] = 0
+    ab = _to_banded(kl, ku, A)
+
+    langb, lange = get_lapack_funcs(('langb', 'lange'), (A,))
+    ref = lange(norm, A)
+    res = langb(norm, kl, ku, ab)
+    assert_allclose(res, ref, rtol=2e-6)
+
+
+@pytest.mark.parametrize('dtype', REAL_DTYPES)
+@pytest.mark.parametrize('compute_v', (0, 1))
+def test_stevd(dtype, compute_v):
+    rng = np.random.default_rng(266474747488348746)
+    n = 10
+    d = rng.random(n, dtype=dtype)
+    e = rng.random(n - 1, dtype=dtype)
+    A = np.diag(e, -1) + np.diag(d) + np.diag(e, 1)
+    ref = np.linalg.eigvalsh(A)
+
+    stevd = get_lapack_funcs('stevd')
+    U, V, info = stevd(d, e, compute_v=compute_v)
+    assert info == 0
+    assert_allclose(np.sort(U), np.sort(ref))
+    if compute_v:
+        eps = np.finfo(dtype).eps
+        assert_allclose(V @ np.diag(U) @ V.T, A, atol=eps**0.8)
+