scipy 1.15.3__cp311-cp311-win_amd64.whl → 1.16.0rc2__cp311-cp311-win_amd64.whl

scipy/linalg/_decomp_cholesky.py

@@ -4,6 +4,7 @@ import numpy as np
 from numpy import asarray_chkfinite, asarray, atleast_2d, empty_like
 
 # Local imports
+from scipy._lib._util import _apply_over_batch
 from ._misc import LinAlgError, _datacopied
 from .lapack import get_lapack_funcs
 
@@ -35,14 +36,18 @@ def _cholesky(a, lower=False, overwrite_a=False, clean=True,
     potrf, = get_lapack_funcs(('potrf',), (a1,))
     c, info = potrf(a1, lower=lower, overwrite_a=overwrite_a, clean=clean)
     if info > 0:
-        raise LinAlgError("%d-th leading minor of the array is not positive "
-                          "definite" % info)
+        raise LinAlgError(
+            f"{info}-th leading minor of the array is not positive definite"
+        )
     if info < 0:
-        raise ValueError(f'LAPACK reported an illegal value in {-info}-th argument'
-                         'on entry to "POTRF".')
+        raise ValueError(
+            f'LAPACK reported an illegal value in {-info}-th argument '
+            f'on entry to "POTRF".'
+        )
     return c, lower
 
 
+@_apply_over_batch(('a', 2))
 def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
     """
     Compute the Cholesky decomposition of a matrix.
@@ -103,6 +108,7 @@ def cholesky(a, lower=False, overwrite_a=False, check_finite=True):
     return c
 
 
+@_apply_over_batch(("a", 2))
 def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):
     """
     Compute the Cholesky decomposition of a matrix, to use in cho_solve
@@ -215,7 +221,12 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):
     True
 
     """
-    (c, lower) = c_and_lower
+    c, lower = c_and_lower
+    return _cho_solve(c, b, lower, overwrite_b=overwrite_b, check_finite=check_finite)
+
+
+@_apply_over_batch(('c', 2), ('b', '1|2'))
+def _cho_solve(c, b, lower, overwrite_b, check_finite):
     if check_finite:
         b1 = asarray_chkfinite(b)
         c = asarray_chkfinite(c)
@@ -239,11 +250,11 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):
     potrs, = get_lapack_funcs(('potrs',), (c, b1))
     x, info = potrs(c, b1, lower=lower, overwrite_b=overwrite_b)
     if info != 0:
-        raise ValueError('illegal value in %dth argument of internal potrs'
-                         % -info)
+        raise ValueError(f'illegal value in {-info}th argument of internal potrs')
     return x
 
 
+@_apply_over_batch(("ab", 2))
 def cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True):
     """
     Cholesky decompose a banded Hermitian positive-definite matrix
@@ -317,10 +328,9 @@ def cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True):
     pbtrf, = get_lapack_funcs(('pbtrf',), (ab,))
     c, info = pbtrf(ab, lower=lower, overwrite_ab=overwrite_ab)
     if info > 0:
-        raise LinAlgError("%d-th leading minor not positive definite" % info)
+        raise LinAlgError(f"{info}-th leading minor not positive definite")
     if info < 0:
-        raise ValueError('illegal value in %d-th argument of internal pbtrf'
-                         % -info)
+        raise ValueError(f'illegal value in {info}-th argument of internal pbtrf')
     return c
 
 
@@ -371,6 +381,12 @@ def cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True):
 
     """
     (cb, lower) = cb_and_lower
+    return _cho_solve_banded(cb, b, lower, overwrite_b=overwrite_b,
+                             check_finite=check_finite)
+
+
+@_apply_over_batch(('cb', 2), ('b', '1|2'))
+def _cho_solve_banded(cb, b, lower, overwrite_b, check_finite):
     if check_finite:
         cb = asarray_chkfinite(cb)
         b = asarray_chkfinite(b)
@@ -391,8 +407,7 @@ def cho_solve_banded(cb_and_lower, b, overwrite_b=False, check_finite=True):
     pbtrs, = get_lapack_funcs(('pbtrs',), (cb, b))
     x, info = pbtrs(cb, b, lower=lower, overwrite_b=overwrite_b)
     if info > 0:
-        raise LinAlgError("%dth leading minor not positive definite" % info)
+        raise LinAlgError(f"{info}th leading minor not positive definite")
     if info < 0:
-        raise ValueError('illegal value in %dth argument of internal pbtrs'
-                         % -info)
+        raise ValueError(f'illegal value in {-info}th argument of internal pbtrs')
     return x

scipy/linalg/_decomp_cossin.py

@@ -1,7 +1,7 @@
 from collections.abc import Iterable
 import numpy as np
 
-from scipy._lib._util import _asarray_validated
+from scipy._lib._util import _asarray_validated, _apply_over_batch
 from scipy.linalg import block_diag, LinAlgError
 from .lapack import _compute_lwork, get_lapack_funcs
 
@@ -80,6 +80,13 @@ def cossin(X, p=None, q=None, separate=False,
         (``m-q`` x ``m-q``) orthogonal/unitary matrices. If ``separate=True``,
         this contains the tuple of ``(V1H, V2H)``.
 
+    Notes
+    -----
+    The documentation is written assuming array arguments are of specified
+    "core" shapes. However, array argument(s) of this function may have additional
+    "batch" dimensions prepended to the core shape. In this case, the array is treated
+    as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details.
+
     References
     ----------
     .. [1] Brian D. Sutton. Computing the complete CS decomposition. Numer.
@@ -111,16 +118,17 @@ def cossin(X, p=None, q=None, separate=False,
         p = 1 if p is None else int(p)
         q = 1 if q is None else int(q)
         X = _asarray_validated(X, check_finite=True)
-        if not np.equal(*X.shape):
+        if not np.equal(*X.shape[-2:]):
             raise ValueError("Cosine Sine decomposition only supports square"
-                             f" matrices, got {X.shape}")
-        m = X.shape[0]
+                             f" matrices, got {X.shape[-2:]}")
+        m = X.shape[-2]
         if p >= m or p <= 0:
-            raise ValueError(f"invalid p={p}, 0<p<{X.shape[0]} must hold")
+            raise ValueError(f"invalid p={p}, 0<p<{X.shape[-2]} must hold")
         if q >= m or q <= 0:
-            raise ValueError(f"invalid q={q}, 0<q<{X.shape[0]} must hold")
+            raise ValueError(f"invalid q={q}, 0<q<{X.shape[-2]} must hold")
 
-        x11, x12, x21, x22 = X[:p, :q], X[:p, q:], X[p:, :q], X[p:, q:]
+        x11, x12, x21, x22 = (X[..., :p, :q], X[..., :p, q:],
+                              X[..., p:, :q], X[..., p:, q:])
     elif not isinstance(X, Iterable):
         raise ValueError("When p and q are None, X must be an Iterable"
                          " containing the subblocks of X")
@@ -128,30 +136,37 @@ def cossin(X, p=None, q=None, separate=False,
         if len(X) != 4:
             raise ValueError("When p and q are None, exactly four arrays"
                              f" should be in X, got {len(X)}")
-
         x11, x12, x21, x22 = (np.atleast_2d(x) for x in X)
-        for name, block in zip(["x11", "x12", "x21", "x22"],
-                               [x11, x12, x21, x22]):
-            if block.shape[1] == 0:
-                raise ValueError(f"{name} can't be empty")
-        p, q = x11.shape
-        mmp, mmq = x22.shape
-
-        if x12.shape != (p, mmq):
-            raise ValueError(f"Invalid x12 dimensions: desired {(p, mmq)}, "
-                             f"got {x12.shape}")
-
-        if x21.shape != (mmp, q):
-            raise ValueError(f"Invalid x21 dimensions: desired {(mmp, q)}, "
-                             f"got {x21.shape}")
-
-        if p + mmp != q + mmq:
-            raise ValueError("The subblocks have compatible sizes but "
-                             "don't form a square array (instead they form a"
-                              f" {p + mmp}x{q + mmq} array). This might be "
-                              "due to missing p, q arguments.")
-
-        m = p + mmp
+
+    return _cossin(x11, x12, x21, x22, separate=separate, swap_sign=swap_sign,
+                   compute_u=compute_u, compute_vh=compute_vh)
+
+
+@_apply_over_batch(('x11', 2), ('x12', 2), ('x21', 2), ('x22', 2))
+def _cossin(x11, x12, x21, x22, separate, swap_sign, compute_u, compute_vh):
+
+    for name, block in zip(["x11", "x12", "x21", "x22"],
+                           [x11, x12, x21, x22]):
+        if block.shape[1] == 0:
+            raise ValueError(f"{name} can't be empty")
+    p, q = x11.shape
+    mmp, mmq = x22.shape
+
+    if x12.shape != (p, mmq):
+        raise ValueError(f"Invalid x12 dimensions: desired {(p, mmq)}, "
+                         f"got {x12.shape}")
+
+    if x21.shape != (mmp, q):
+        raise ValueError(f"Invalid x21 dimensions: desired {(mmp, q)}, "
+                         f"got {x21.shape}")
+
+    if p + mmp != q + mmq:
+        raise ValueError("The subblocks have compatible sizes but "
+                         "don't form a square array (instead they form a"
+                          f" {p + mmp}x{q + mmq} array). This might be "
+                          "due to missing p, q arguments.")
+
+    m = p + mmp
 
     cplx = any([np.iscomplexobj(x) for x in [x11, x12, x21, x22]])
     driver = "uncsd" if cplx else "orcsd"

scipy/linalg/_decomp_ldl.py

@@ -3,13 +3,16 @@ from warnings import warn
 import numpy as np
 from numpy import (atleast_2d, arange, zeros_like, imag, diag,
                    iscomplexobj, tril, triu, argsort, empty_like)
-from scipy._lib._util import ComplexWarning
+from numpy.exceptions import ComplexWarning
+
+from scipy._lib._util import _apply_over_batch
 from ._decomp import _asarray_validated
 from .lapack import get_lapack_funcs, _compute_lwork
 
 __all__ = ['ldl']
 
 
+@_apply_over_batch(('A', 2))
 def ldl(A, lower=True, hermitian=True, overwrite_a=False, check_finite=True):
     """ Computes the LDLt or Bunch-Kaufman factorization of a symmetric/
     hermitian matrix.

scipy/linalg/_decomp_lu.py

@@ -6,6 +6,8 @@ from numpy import asarray, asarray_chkfinite
 import numpy as np
 from itertools import product
 
+from scipy._lib._util import _apply_over_batch
+
 # Local imports
 from ._misc import _datacopied, LinAlgWarning
 from .lapack import get_lapack_funcs
@@ -17,6 +19,7 @@ lapack_cast_dict = {x: ''.join([y for y in 'fdFD' if np.can_cast(x, y)])
 __all__ = ['lu', 'lu_solve', 'lu_factor']
 
 
+@_apply_over_batch(('a', 2))
 def lu_factor(a, overwrite_a=False, check_finite=True):
     """
     Compute pivoted LU decomposition of a matrix.
@@ -118,11 +121,15 @@ def lu_factor(a, overwrite_a=False, check_finite=True):
     getrf, = get_lapack_funcs(('getrf',), (a1,))
     lu, piv, info = getrf(a1, overwrite_a=overwrite_a)
     if info < 0:
-        raise ValueError('illegal value in %dth argument of '
-                         'internal getrf (lu_factor)' % -info)
+        raise ValueError(
+            f'illegal value in {-info}th argument of internal getrf (lu_factor)'
+        )
     if info > 0:
-        warn("Diagonal number %d is exactly zero. Singular matrix." % info,
-             LinAlgWarning, stacklevel=2)
+        warn(
+            f"Diagonal number {info} is exactly zero. Singular matrix.",
+            LinAlgWarning,
+            stacklevel=2
+        )
     return lu, piv
 
 
@@ -175,6 +182,12 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
 
     """
     (lu, piv) = lu_and_piv
+    return _lu_solve(lu, piv, b, trans=trans, overwrite_b=overwrite_b,
+                     check_finite=check_finite)
+
+
+@_apply_over_batch(('lu', 2), ('piv', 1), ('b', '1|2'))
+def _lu_solve(lu, piv, b, trans, overwrite_b, check_finite):
     if check_finite:
         b1 = asarray_chkfinite(b)
     else:
@@ -194,8 +207,7 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
     x, info = getrs(lu, piv, b1, trans=trans, overwrite_b=overwrite_b)
     if info == 0:
         return x
-    raise ValueError('illegal value in %dth argument of internal gesv|posv'
-                     % -info)
+    raise ValueError(f'illegal value in {-info}th argument of internal gesv|posv')
 
 
 def lu(a, permute_l=False, overwrite_a=False, check_finite=True,

scipy/linalg/_decomp_polar.py

@@ -1,10 +1,12 @@
 import numpy as np
+from scipy._lib._util import _apply_over_batch
 from scipy.linalg import svd
 
 
 __all__ = ['polar']
 
 
+@_apply_over_batch(('a', 2))
 def polar(a, side="right"):
     """
     Compute the polar decomposition.

scipy/linalg/_decomp_qr.py

@@ -1,6 +1,8 @@
 """QR decomposition functions."""
 import numpy as np
 
+from scipy._lib._util import _apply_over_batch
+
 # Local imports
 from .lapack import get_lapack_funcs
 from ._misc import _datacopied
@@ -18,11 +20,11 @@ def safecall(f, name, *args, **kwargs):
         kwargs['lwork'] = ret[-2][0].real.astype(np.int_)
     ret = f(*args, **kwargs)
     if ret[-1] < 0:
-        raise ValueError("illegal value in %dth argument of internal %s"
-                         % (-ret[-1], name))
+        raise ValueError(f"illegal value in {-ret[-1]}th argument of internal {name}")
     return ret[:-2]
 
 
+@_apply_over_batch(('a', 2))
 def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False,
        check_finite=True):
     """
@@ -214,6 +216,7 @@ def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False,
     return (Q,) + Rj
 
 
+@_apply_over_batch(('a', 2), ('c', '1|2'))
 def qr_multiply(a, c, mode='right', pivoting=False, conjugate=False,
                 overwrite_a=False, overwrite_c=False):
     """
@@ -366,6 +369,7 @@ def qr_multiply(a, c, mode='right', pivoting=False, conjugate=False,
     return (cQ,) + raw[1:]
 
 
+@_apply_over_batch(('a', 2))
 def rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True):
     """
     Compute RQ decomposition of a matrix.

scipy/linalg/_decomp_qz.py

@@ -2,6 +2,7 @@ import warnings
 
 import numpy as np
 from numpy import asarray_chkfinite
+from scipy._lib._util import _apply_over_batch
 from ._misc import LinAlgError, _datacopied, LinAlgWarning
 from .lapack import get_lapack_funcs
 
@@ -142,6 +143,7 @@ def _qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False,
     return result, gges.typecode
 
 
+@_apply_over_batch(('A', 2), ('B', 2))
 def qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False,
        overwrite_b=False, check_finite=True):
     """
@@ -317,6 +319,7 @@ def qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False,
     return result[0], result[1], result[-4], result[-3]
 
 
+@_apply_over_batch(('A', 2), ('B', 2))
 def ordqz(A, B, sort='lhp', output='real', overwrite_a=False,
           overwrite_b=False, check_finite=True):
     """QZ decomposition for a pair of matrices with reordering.

scipy/linalg/_decomp_schur.py

@@ -3,7 +3,7 @@ import numpy as np
 from numpy import asarray_chkfinite, single, asarray, array
 from numpy.linalg import norm
 
-
+from scipy._lib._util import _apply_over_batch
 # Local imports.
 from ._misc import LinAlgError, _datacopied
 from .lapack import get_lapack_funcs
@@ -14,6 +14,7 @@ __all__ = ['schur', 'rsf2csf']
 _double_precision = ['i', 'l', 'd']
 
 
+@_apply_over_batch(('a', 2))
 def schur(a, output='real', lwork=None, overwrite_a=False, sort=None,
           check_finite=True):
     """
@@ -248,6 +249,7 @@ def _castCopy(type, *arrays):
         return cast_arrays
 
 
+@_apply_over_batch(('T', 2), ('Z', 2))
 def rsf2csf(T, Z, check_finite=True):
     """
     Convert real Schur form to complex Schur form.

scipy/linalg/_decomp_svd.py

@@ -2,14 +2,18 @@
 import numpy as np
 from numpy import zeros, r_, diag, dot, arccos, arcsin, where, clip
 
+from scipy._lib._util import _apply_over_batch
+
 # Local imports.
 from ._misc import LinAlgError, _datacopied
 from .lapack import get_lapack_funcs, _compute_lwork
 from ._decomp import _asarray_validated
 
+
 __all__ = ['svd', 'svdvals', 'diagsvd', 'orth', 'subspace_angles', 'null_space']
 
 
+@_apply_over_batch(('a', 2))
 def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False,
         check_finite=True, lapack_driver='gesdd'):
     """
@@ -165,14 +169,17 @@ def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False,
     if info > 0:
         raise LinAlgError("SVD did not converge")
     if info < 0:
-        raise ValueError('illegal value in %dth argument of internal gesdd'
-                         % -info)
+        if lapack_driver == "gesdd" and info == -4:
+            msg = "A has a NaN entry"
+            raise ValueError(msg)
+        raise ValueError(f'illegal value in {-info}th argument of internal gesdd')
     if compute_uv:
         return u, s, v
     else:
         return s
 
 
+@_apply_over_batch(('a', 2))
 def svdvals(a, overwrite_a=False, check_finite=True):
     """
     Compute singular values of a matrix.
@@ -249,6 +256,7 @@ def svdvals(a, overwrite_a=False, check_finite=True):
                check_finite=check_finite)
 
 
+@_apply_over_batch(('s', 1))
 def diagsvd(s, M, N):
     """
     Construct the sigma matrix in SVD from singular values and size M, N.
@@ -301,6 +309,7 @@ def diagsvd(s, M, N):
 
 # Orthonormal decomposition
 
+@_apply_over_batch(('A', 2))
 def orth(A, rcond=None):
     """
     Construct an orthonormal basis for the range of A using SVD
@@ -349,6 +358,7 @@ def orth(A, rcond=None):
     return Q
 
 
+@_apply_over_batch(('A', 2))
 def null_space(A, rcond=None, *, overwrite_a=False, check_finite=True,
                lapack_driver='gesdd'):
     """
@@ -427,6 +437,7 @@ def null_space(A, rcond=None, *, overwrite_a=False, check_finite=True,
     return Q
 
 
+@_apply_over_batch(('A', 2), ('B', 2))
 def subspace_angles(A, B):
     r"""
     Compute the subspace angles between two matrices.

scipy/linalg/_expm_frechet.py

@@ -1,10 +1,13 @@
 """Frechet derivative of the matrix exponential."""
 import numpy as np
 import scipy.linalg
+from scipy._lib._util import _apply_over_batch
+
 
 __all__ = ['expm_frechet', 'expm_cond']
 
 
+@_apply_over_batch(('A', 2), ('E', 2))
 def expm_frechet(A, E, method=None, compute_expm=True, check_finite=True):
     """
     Frechet derivative of the matrix exponential of A in the direction E.
@@ -351,6 +354,7 @@ def expm_frechet_kronform(A, method=None, check_finite=True):
     return np.vstack(cols).T
 
 
+@_apply_over_batch(('A', 2))
 def expm_cond(A, check_finite=True):
     """
     Relative condition number of the matrix exponential in the Frobenius norm.