scipy 1.15.3__cp312-cp312-win_amd64.whl → 1.16.0rc2__cp312-cp312-win_amd64.whl

scipy/linalg/_basic.py

@@ -9,6 +9,7 @@ from warnings import warn
 from itertools import product
 import numpy as np
 from numpy import atleast_1d, atleast_2d
+from scipy._lib._util import _apply_over_batch
 from .lapack import get_lapack_funcs, _compute_lwork
 from ._misc import LinAlgError, _datacopied, LinAlgWarning
 from ._decomp import _asarray_validated
@@ -38,13 +39,13 @@ def _solve_check(n, info, lamch=None, rcond=None):
     """ Check arguments during the different steps of the solution phase """
     if info < 0:
         raise ValueError(f'LAPACK reported an illegal value in {-info}-th argument.')
-    elif 0 < info:
+    elif 0 < info or rcond == 0:
         raise LinAlgError('Matrix is singular.')
 
     if lamch is None:
         return
     E = lamch('E')
-    if rcond < E:
+    if not (rcond >= E):  # `rcond < E` doesn't handle NaN
         warn(f'Ill-conditioned matrix (rcond={rcond:.6g}): '
              'result may not be accurate.',
              LinAlgWarning, stacklevel=3)
@@ -72,28 +73,29 @@ def _find_matrix_structure(a):
     return kind, n_below, n_above
 
 
+@_apply_over_batch(('a', 2), ('b', '1|2'))
 def solve(a, b, lower=False, overwrite_a=False,
           overwrite_b=False, check_finite=True, assume_a=None,
           transposed=False):
     """
-    Solves the linear equation set ``a @ x == b`` for the unknown ``x``
-    for square `a` matrix.
+    Solve the equation ``a @ x = b`` for  ``x``,
+    where `a` is a square matrix.
 
     If the data matrix is known to be a particular type then supplying the
     corresponding string to ``assume_a`` key chooses the dedicated solver.
     The available options are
 
-    ===================  ================================
-     diagonal             'diagonal'
-     tridiagonal          'tridiagonal'
-     banded               'banded'
-     upper triangular     'upper triangular'
-     lower triangular     'lower triangular'
-     symmetric            'symmetric' (or 'sym')
-     hermitian            'hermitian' (or 'her')
-     positive definite    'positive definite' (or 'pos')
-     general              'general' (or 'gen')
-    ===================  ================================
+    =============================  ================================
+     diagonal                       'diagonal'
+     tridiagonal                    'tridiagonal'
+     banded                         'banded'
+     upper triangular               'upper triangular'
+     lower triangular               'lower triangular'
+     symmetric                      'symmetric' (or 'sym')
+     hermitian                      'hermitian' (or 'her')
+     symmetric positive definite    'positive definite' (or 'pos')
+     general                        'general' (or 'gen')
+    =============================  ================================
 
     Parameters
     ----------
@@ -133,7 +135,7 @@ def solve(a, b, lower=False, overwrite_a=False,
     ValueError
         If size mismatches detected or input a is not square.
     LinAlgError
-        If the matrix is singular.
+        If the computation fails because of matrix singularity.
     LinAlgWarning
         If an ill-conditioned input a is detected.
     NotImplementedError
@@ -226,17 +228,6 @@ def solve(a, b, lower=False, overwrite_a=False,
     else:
         lamch = get_lapack_funcs('lamch', dtype='d')
 
-    # Currently we do not have the other forms of the norm calculators
-    #   lansy, lanpo, lanhe.
-    # However, in any case they only reduce computations slightly...
-    if assume_a == 'diagonal':
-        _matrix_norm = _matrix_norm_diagonal
-    elif assume_a == 'tridiagonal':
-        _matrix_norm = _matrix_norm_tridiagonal
-    elif assume_a in {'lower triangular', 'upper triangular'}:
-        _matrix_norm = _matrix_norm_triangular(assume_a)
-    else:
-        _matrix_norm = _matrix_norm_general
 
     # Since the I-norm and 1-norm are the same for symmetric matrices
     # we can collect them all in this one call
@@ -253,7 +244,23 @@ def solve(a, b, lower=False, overwrite_a=False,
         trans = 0
         norm = '1'
 
-    anorm = _matrix_norm(norm, a1, check_finite)
+    # Currently we do not have the other forms of the norm calculators
+    #   lansy, lanpo, lanhe.
+    # However, in any case they only reduce computations slightly...
+    if assume_a == 'diagonal':
+        anorm = _matrix_norm_diagonal(a1, check_finite)
+    elif assume_a == 'tridiagonal':
+        anorm = _matrix_norm_tridiagonal(norm, a1, check_finite)
+    elif assume_a == 'banded':
+        n_below, n_above = bandwidth(a1) if n_below is None else (n_below, n_above)
+        a2, n_below, n_above = ((a1.T, n_above, n_below) if transposed
+                                else (a1, n_below, n_above))
+        ab = _to_banded(n_below, n_above, a2)
+        anorm = _matrix_norm_banded(n_below, n_above, norm, ab, check_finite)
+    elif assume_a in {'lower triangular', 'upper triangular'}:
+        anorm = _matrix_norm_triangular(assume_a, norm, a1, check_finite)
+    else:
+        anorm = _matrix_norm_general(norm, a1, check_finite)
 
     info, rcond = 0, np.inf
 
@@ -277,7 +284,7 @@ def solve(a, b, lower=False, overwrite_a=False,
                                  overwrite_a=overwrite_a,
                                  overwrite_b=overwrite_b)
         _solve_check(n, info)
-        rcond, info = hecon(lu, ipvt, anorm)
+        rcond, info = hecon(lu, ipvt, anorm, lower=lower)
     # Symmetric case 'sysv'
     elif assume_a in {'symmetric', 'sym'}:
         sycon, sysv, sysv_lw = get_lapack_funcs(('sycon', 'sysv',
@@ -288,13 +295,14 @@ def solve(a, b, lower=False, overwrite_a=False,
                                  overwrite_a=overwrite_a,
                                  overwrite_b=overwrite_b)
         _solve_check(n, info)
-        rcond, info = sycon(lu, ipvt, anorm)
+        rcond, info = sycon(lu, ipvt, anorm, lower=lower)
     # Diagonal case
     elif assume_a == 'diagonal':
         diag_a = np.diag(a1)
         x = (b1.T / diag_a).T
         abs_diag_a = np.abs(diag_a)
-        rcond = abs_diag_a.min() / abs_diag_a.max()
+        diag_min = abs_diag_a.min()
+        rcond = diag_min if diag_min == 0 else diag_min / abs_diag_a.max()
     # Tri-diagonal case
     elif assume_a == 'tridiagonal':
         a1 = a1.T if transposed else a1
@@ -307,18 +315,14 @@ def solve(a, b, lower=False, overwrite_a=False,
         rcond, info = _gtcon(dl, d, du, du2, ipiv, anorm)
     # Banded case
     elif assume_a == 'banded':
-        a1, n_below, n_above = ((a1.T, n_above, n_below) if transposed
-                                else (a1, n_below, n_above))
-        n_below, n_above = bandwidth(a1) if n_below is None else (n_below, n_above)
-        ab = _to_banded(n_below, n_above, a1)
-        gbsv, = get_lapack_funcs(('gbsv',), (a1, b1))
+        gbsv, gbcon = get_lapack_funcs(('gbsv', 'gbcon'), (a1, b1))
         # Next two lines copied from `solve_banded`
         a2 = np.zeros((2*n_below + n_above + 1, ab.shape[1]), dtype=gbsv.dtype)
         a2[n_below:, :] = ab
-        _, _, x, info = gbsv(n_below, n_above, a2, b1,
-                             overwrite_ab=True, overwrite_b=overwrite_b)
+        lu, piv, x, info = gbsv(n_below, n_above, a2, b1,
+                                overwrite_ab=True, overwrite_b=overwrite_b)
         _solve_check(n, info)
-        # TODO: wrap gbcon and use to get rcond
+        rcond, info = gbcon(n_below, n_above, lu, piv, anorm)
     # Triangular case
     elif assume_a in {'lower triangular', 'upper triangular'}:
         lower = assume_a == 'lower triangular'
@@ -345,7 +349,7 @@ def solve(a, b, lower=False, overwrite_a=False,
     return x
 
 
-def _matrix_norm_diagonal(_, a, check_finite):
+def _matrix_norm_diagonal(a, check_finite):
     # Equivalent of dlange for diagonal matrix, assuming
     # norm is either 'I' or '1' (really just not the Frobenius norm)
     d = np.diag(a)
@@ -367,12 +371,16 @@ def _matrix_norm_tridiagonal(norm, a, check_finite):
     return d.max()
 
 
-def _matrix_norm_triangular(structure):
-    def fun(norm, a, check_finite):
-        a = np.asarray_chkfinite(a) if check_finite else a
-        lantr = get_lapack_funcs('lantr', (a,))
-        return lantr(norm, a, 'L' if structure == 'lower triangular' else 'U' )
-    return fun
+def _matrix_norm_triangular(structure, norm, a, check_finite):
+    a = np.asarray_chkfinite(a) if check_finite else a
+    lantr = get_lapack_funcs('lantr', (a,))
+    return lantr(norm, a, 'L' if structure == 'lower triangular' else 'U' )
+
+
+def _matrix_norm_banded(kl, ku, norm, ab, check_finite):
+    ab = np.asarray_chkfinite(ab) if check_finite else ab
+    langb = get_lapack_funcs('langb', (ab,))
+    return langb(norm, kl, ku, ab)
 
 
 def _matrix_norm_general(norm, a, check_finite):
@@ -408,10 +416,11 @@ def _ensure_dtype_cdsz(*arrays):
     return (array.astype(dtype, copy=False) for array in arrays)
 
 
+@_apply_over_batch(('a', 2), ('b', '1|2'))
 def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False,
                      overwrite_b=False, check_finite=True):
     """
-    Solve the equation ``a x = b`` for `x`, assuming a is a triangular matrix.
+    Solve the equation ``a @ x = b`` for ``x``, where `a` is a triangular matrix.
 
     Parameters
     ----------
@@ -516,16 +525,15 @@ def _solve_triangular(a1, b1, trans=0, lower=False, unit_diagonal=False,
     if info == 0:
         return x, info
     if info > 0:
-        raise LinAlgError("singular matrix: resolution failed at diagonal %d" %
-                          (info-1))
-    raise ValueError('illegal value in %dth argument of internal trtrs' %
-                     (-info))
+        raise LinAlgError(f"singular matrix: resolution failed at diagonal {info-1}")
+    raise ValueError(f'illegal value in {-info}-th argument of internal trtrs')
 
 
 def solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False,
                  check_finite=True):
     """
-    Solve the equation a x = b for x, assuming a is banded matrix.
+    Solve the equation ``a @ x = b`` for ``x``, where ``a`` is the banded matrix
+    defined by `ab`.
 
     The matrix a is stored in `ab` using the matrix diagonal ordered form::
 
@@ -591,7 +599,13 @@ def solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False,
     array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])
 
     """
+    (nlower, nupper) = l_and_u
+    return _solve_banded(nlower, nupper, ab, b, overwrite_ab=overwrite_ab,
+                         overwrite_b=overwrite_b, check_finite=check_finite)
+
 
+@_apply_over_batch(('nlower', 0), ('nupper', 0), ('ab', 2), ('b', '1|2'))
+def _solve_banded(nlower, nupper, ab, b, overwrite_ab, overwrite_b, check_finite):
     a1 = _asarray_validated(ab, check_finite=check_finite, as_inexact=True)
     b1 = _asarray_validated(b, check_finite=check_finite, as_inexact=True)
 
@@ -599,11 +613,11 @@ def solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False,
     if a1.shape[-1] != b1.shape[0]:
         raise ValueError("shapes of ab and b are not compatible.")
 
-    (nlower, nupper) = l_and_u
     if nlower + nupper + 1 != a1.shape[0]:
-        raise ValueError("invalid values for the number of lower and upper "
-                         "diagonals: l+u+1 (%d) does not equal ab.shape[0] "
-                         "(%d)" % (nlower + nupper + 1, ab.shape[0]))
+        raise ValueError(
+            f"invalid values for the number of lower and upper diagonals: l+u+1 "
+            f"({nlower + nupper + 1}) does not equal ab.shape[0] ({ab.shape[0]})"
+        )
 
     # accommodate empty arrays
     if b1.size == 0:
@@ -638,14 +652,15 @@ def solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False,
         return x
     if info > 0:
         raise LinAlgError("singular matrix")
-    raise ValueError('illegal value in %d-th argument of internal '
-                     'gbsv/gtsv' % -info)
+    raise ValueError(f'illegal value in {-info}-th argument of internal gbsv/gtsv')
 
 
+@_apply_over_batch(('a', 2), ('b', '1|2'))
 def solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False,
                   check_finite=True):
     """
-    Solve equation a x = b. a is Hermitian positive-definite banded matrix.
+    Solve the equation ``a @ x = b`` for ``x``,  where ``a`` is the 
+    Hermitian positive-definite banded matrix defined by `ab`.
 
     Uses Thomas' Algorithm, which is more efficient than standard LU
     factorization, but should only be used for Hermitian positive-definite
@@ -775,18 +790,18 @@ def solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False,
         c, x, info = pbsv(a1, b1, lower=lower, overwrite_ab=overwrite_ab,
                           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 '
-                         'pbsv' % -info)
+        raise ValueError(f'illegal value in {-info}th argument of internal pbsv')
     return x
 
 
 def solve_toeplitz(c_or_cr, b, check_finite=True):
-    r"""Solve a Toeplitz system using Levinson Recursion
+    r"""Solve the equation ``T @ x = b`` for ``x``, where ``T`` is a Toeplitz
+    matrix defined by `c_or_cr`.
 
-    The Toeplitz matrix has constant diagonals, with c as its first column
-    and r as its first row. If r is not given, ``r == conjugate(c)`` is
+    The Toeplitz matrix has constant diagonals, with ``c`` as its first column
+    and ``r`` as its first row. If ``r`` is not given, ``r == conjugate(c)`` is
     assumed.
 
     .. warning::
@@ -812,7 +827,7 @@ def solve_toeplitz(c_or_cr, b, check_finite=True):
     Returns
     -------
     x : (M,) or (M, K) ndarray
-        The solution to the system ``T x = b``. Shape of return matches shape
+        The solution to the system ``T @ x = b``. Shape of return matches shape
         of `b`.
 
     See Also
@@ -826,7 +841,7 @@ def solve_toeplitz(c_or_cr, b, check_finite=True):
 
     Examples
     --------
-    Solve the Toeplitz system T x = b, where::
+    Solve the Toeplitz system ``T @ x = b``, where::
 
             [ 1 -1 -2 -3]       [1]
         T = [ 3  1 -1 -2]   b = [2]
@@ -847,7 +862,7 @@ def solve_toeplitz(c_or_cr, b, check_finite=True):
     array([ 1.66666667, -1.        , -2.66666667,  2.33333333])
 
     Check the result by creating the full Toeplitz matrix and
-    multiplying it by `x`.  We should get `b`.
+    multiplying it by ``x``.  We should get `b`.
 
     >>> T = toeplitz(c, r)
     >>> T.dot(x)
@@ -857,9 +872,15 @@ def solve_toeplitz(c_or_cr, b, check_finite=True):
     # If numerical stability of this algorithm is a problem, a future
     # developer might consider implementing other O(N^2) Toeplitz solvers,
     # such as GKO (https://www.jstor.org/stable/2153371) or Bareiss.
+    c, r = c_or_cr if isinstance(c_or_cr, tuple) else (c_or_cr, np.conjugate(c_or_cr))
+    return _solve_toeplitz(c, r, b, check_finite)
 
+
+# Can uncomment when `solve_toeplitz` deprecation is done (SciPy 1.17)
+# @_apply_over_batch(('c', 1), ('r', 1), ('b', '1|2'))
+def _solve_toeplitz(c, r, b, check_finite):
     r, c, b, dtype, b_shape = _validate_args_for_toeplitz_ops(
-        c_or_cr, b, check_finite, keep_b_shape=True)
+        (c, r), b, check_finite, keep_b_shape=True)
 
     # accommodate empty arrays
     if b.size == 0:
@@ -892,7 +913,8 @@ def _get_axis_len(aname, a, axis):
 
 def solve_circulant(c, b, singular='raise', tol=None,
                     caxis=-1, baxis=0, outaxis=0):
-    """Solve C x = b for x, where C is a circulant matrix.
+    """Solve the equation ``C @ x = b`` for ``x``, where ``C`` is a
+    circulant matrix defined by `c`.
 
     `C` is the circulant matrix associated with the vector `c`.
 
@@ -1094,6 +1116,7 @@ def solve_circulant(c, b, singular='raise', tol=None,
 
 
 # matrix inversion
+@_apply_over_batch(('a', 2))
 def inv(a, overwrite_a=False, check_finite=True):
     """
     Compute the inverse of a matrix.
@@ -1162,8 +1185,9 @@ def inv(a, overwrite_a=False, check_finite=True):
     if info > 0:
         raise LinAlgError("singular matrix")
     if info < 0:
-        raise ValueError('illegal value in %d-th argument of internal '
-                         'getrf|getri' % -info)
+        raise ValueError(
+            f'illegal value in {-info}-th argument of internal getrf|getri'
+        )
     return inv_a
 
 
@@ -1298,10 +1322,11 @@ def det(a, overwrite_a=False, check_finite=True):
 
 
 # Linear Least Squares
+@_apply_over_batch(('a', 2), ('b', '1|2'))
 def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False,
           check_finite=True, lapack_driver=None):
     """
-    Compute least-squares solution to equation Ax = b.
+    Compute least-squares solution to the equation ``a @ x = b``.
 
     Compute a vector x such that the 2-norm ``|b - A x|`` is minimized.
 
@@ -1477,8 +1502,9 @@ def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False,
         if info > 0:
             raise LinAlgError("SVD did not converge in Linear Least Squares")
         if info < 0:
-            raise ValueError('illegal value in %d-th argument of internal %s'
-                             % (-info, lapack_driver))
+            raise ValueError(
+                f'illegal value in {-info}-th argument of internal {lapack_driver}'
+            )
         resids = np.asarray([], dtype=x.dtype)
         if m > n:
             x1 = x[:n]
@@ -1493,8 +1519,7 @@ def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False,
         v, x, j, rank, info = lapack_func(a1, b1, jptv, cond,
                                           lwork, False, False)
         if info < 0:
-            raise ValueError("illegal value in %d-th argument of internal "
-                             "gelsy" % -info)
+            raise ValueError(f'illegal value in {-info}-th argument of internal gelsy')
         if m > n:
             x1 = x[:n]
             x = x1
@@ -1504,6 +1529,7 @@ def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False,
 lstsq.default_lapack_driver = 'gelsd'
 
 
+@_apply_over_batch(('a', 2))
 def pinv(a, *, atol=None, rtol=None, return_rank=False, check_finite=True):
     """
     Compute the (Moore-Penrose) pseudo-inverse of a matrix.
@@ -1627,6 +1653,7 @@ def pinv(a, *, atol=None, rtol=None, return_rank=False, check_finite=True):
         return B
 
 
+@_apply_over_batch(('a', 2))
 def pinvh(a, atol=None, rtol=None, lower=True, return_rank=False,
           check_finite=True):
     """
@@ -1720,6 +1747,7 @@ def pinvh(a, atol=None, rtol=None, lower=True, return_rank=False,
         return B
 
 
+@_apply_over_batch(('A', 2))
 def matrix_balance(A, permute=True, scale=True, separate=False,
                    overwrite_a=False):
     """
@@ -1733,15 +1761,6 @@ def matrix_balance(A, permute=True, scale=True, separate=False,
     triangular parts of the matrix and, again if scaling is also enabled,
     only the remaining subblocks are subjected to scaling.
 
-    The balanced matrix satisfies the following equality
-
-    .. math::
-
-                        B = T^{-1} A T
-
-    The scaling coefficients are approximated to the nearest power of 2
-    to avoid round-off errors.
-
     Parameters
     ----------
     A : (n, n) array_like
@@ -1774,6 +1793,14 @@ def matrix_balance(A, permute=True, scale=True, separate=False,
 
     Notes
     -----
+    The balanced matrix satisfies the following equality
+
+    .. math::
+        B = T^{-1} A T
+
+    The scaling coefficients are approximated to the nearest power of 2
+    to avoid round-off errors.
+
     This algorithm is particularly useful for eigenvalue and matrix
     decompositions and in many cases it is already called by various
     LAPACK routines.

scipy/linalg/_decomp.py

@@ -21,7 +21,7 @@ from numpy import (array, isfinite, inexact, nonzero, iscomplexobj,
                    flatnonzero, conj, asarray, argsort, empty,
                    iscomplex, zeros, einsum, eye, inf)
 # Local imports
-from scipy._lib._util import _asarray_validated
+from scipy._lib._util import _asarray_validated, _apply_over_batch
 from ._misc import LinAlgError, _datacopied, norm
 from .lapack import get_lapack_funcs, _compute_lwork
 
@@ -111,6 +111,7 @@ def _geneig(a1, b1, left, right, overwrite_a, overwrite_b,
     return w, vr
 
 
+@_apply_over_batch(('a', 2), ('b', 2))
 def eig(a, b=None, left=False, right=True, overwrite_a=False,
         overwrite_b=False, check_finite=True, homogeneous_eigvals=False):
     """
@@ -280,6 +281,7 @@ def eig(a, b=None, left=False, right=True, overwrite_a=False,
     return w, vr
 
 
+@_apply_over_batch(('a', 2), ('b', 2))
 def eigh(a, b=None, *, lower=True, eigvals_only=False, overwrite_a=False,
          overwrite_b=False, type=1, check_finite=True, subset_by_index=None,
          subset_by_value=None, driver=None):
@@ -656,6 +658,7 @@ def _check_select(select, select_range, max_ev, max_len):
     return select, vl, vu, il, iu, max_ev
 
 
+@_apply_over_batch(('a_band', 2))
 def eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False,
                select='a', select_range=None, max_ev=0, check_finite=True):
     """
@@ -835,6 +838,7 @@ def eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False,
     return w, v
 
 
+@_apply_over_batch(('a', 2), ('b', 2))
 def eigvals(a, b=None, overwrite_a=False, check_finite=True,
             homogeneous_eigvals=False):
     """
@@ -910,6 +914,7 @@ def eigvals(a, b=None, overwrite_a=False, check_finite=True,
                homogeneous_eigvals=homogeneous_eigvals)
 
 
+@_apply_over_batch(('a', 2), ('b', 2))
 def eigvalsh(a, b=None, *, lower=True, overwrite_a=False,
              overwrite_b=False, type=1, check_finite=True, subset_by_index=None,
              subset_by_value=None, driver=None):
@@ -1028,6 +1033,7 @@ def eigvalsh(a, b=None, *, lower=True, overwrite_a=False,
                 driver=driver)
 
 
+@_apply_over_batch(('a_band', 2))
 def eigvals_banded(a_band, lower=False, overwrite_a_band=False,
                    select='a', select_range=None, check_finite=True):
     """
@@ -1121,6 +1127,7 @@ def eigvals_banded(a_band, lower=False, overwrite_a_band=False,
                       select_range=select_range, check_finite=check_finite)
 
 
+@_apply_over_batch(('d', 1), ('e', 1))
 def eigvalsh_tridiagonal(d, e, select='a', select_range=None,
                          check_finite=True, tol=0., lapack_driver='auto'):
     """
@@ -1165,9 +1172,9 @@ def eigvalsh_tridiagonal(d, e, select='a', select_range=None,
         and ``|a|`` is the 1-norm of the matrix ``a``.
     lapack_driver : str
         LAPACK function to use, can be 'auto', 'stemr', 'stebz',  'sterf',
-        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
-        and 'stebz' otherwise. 'sterf' and 'stev' can only be used when
-        ``select='a'``.
+        'stev', or 'stevd'. When 'auto' (default), it will use 'stevd' if
+        ``select='a'`` and 'stebz' otherwise. 'sterf' and 'stev' can only
+        be used when ``select='a'``.
 
     Returns
     -------
@@ -1202,6 +1209,7 @@ def eigvalsh_tridiagonal(d, e, select='a', select_range=None,
         check_finite=check_finite, tol=tol, lapack_driver=lapack_driver)
 
 
+@_apply_over_batch(('d', 1), ('e', 1))
 def eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None,
                      check_finite=True, tol=0., lapack_driver='auto'):
     """
@@ -1249,7 +1257,7 @@ def eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None,
         and ``|a|`` is the 1-norm of the matrix ``a``.
     lapack_driver : str
         LAPACK function to use, can be 'auto', 'stemr', 'stebz', 'sterf',
-        or 'stev'. When 'auto' (default), it will use 'stemr' if ``select='a'``
+        'stev', or 'stevd'. When 'auto' (default), it will use 'stevd' if ``select='a'``
         and 'stebz' otherwise. When 'stebz' is used to find the eigenvalues and
         ``eigvals_only=False``, then a second LAPACK call (to ``?STEIN``) is
         used to find the corresponding eigenvectors. 'sterf' can only be
@@ -1307,12 +1315,12 @@ def eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None,
         select, select_range, 0, d.size)
     if not isinstance(lapack_driver, str):
         raise TypeError('lapack_driver must be str')
-    drivers = ('auto', 'stemr', 'sterf', 'stebz', 'stev')
+    drivers = ('auto', 'stemr', 'sterf', 'stebz', 'stev', 'stevd')
     if lapack_driver not in drivers:
         raise ValueError(f'lapack_driver must be one of {drivers}, '
                          f'got {lapack_driver}')
     if lapack_driver == 'auto':
-        lapack_driver = 'stemr' if select == 0 else 'stebz'
+        lapack_driver = 'stevd' if select == 0 else 'stebz'
 
     # Quick exit for 1x1 case
     if len(d) == 1:
@@ -1343,6 +1351,11 @@ def eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None,
             raise ValueError('stev can only be used when select == "a"')
         w, v, info = func(d, e, compute_v=compute_v)
         m = len(w)
+    elif lapack_driver == 'stevd':
+        if select != 0:
+            raise ValueError('stevd can only be used when select == "a"')
+        w, v, info = func(d, e, compute_v=compute_v)
+        m = len(w)
     elif lapack_driver == 'stebz':
         tol = float(tol)
         internal_name = 'stebz'
@@ -1384,12 +1397,12 @@ def eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None,
 def _check_info(info, driver, positive='did not converge (LAPACK info=%d)'):
     """Check info return value."""
     if info < 0:
-        raise ValueError('illegal value in argument %d of internal %s'
-                         % (-info, driver))
+        raise ValueError(f'illegal value in argument {-info} of internal {driver}')
     if info > 0 and positive:
         raise LinAlgError(("%s " + positive) % (driver, info,))
 
 
+@_apply_over_batch(('a', 2))
 def hessenberg(a, calc_q=False, overwrite_a=False, check_finite=True):
     """
     Compute Hessenberg form of a matrix.