Pin scipy to latest version 1.17.1

[pyup-bot]

This PR pins scipy to the latest release 1.17.1.

Changelog

1.17.0

many new features, numerous bug-fixes, improved test coverage and better
documentation. There have been a number of deprecations and API changes
in this release, which are documented below. All users are encouraged to
upgrade to this release, as there are a large number of bug-fixes and
optimizations. Before upgrading, we recommend that users check that
their own code does not use deprecated SciPy functionality (to do so,
run your code with ``python -Wd`` and check for ``DeprecationWarning`` s).
Our development attention will now shift to bug-fix releases on the
1.17.x branch, and on adding new features on the main branch.

This release requires Python 3.11-3.14 and NumPy 1.26.4 or greater.

Highlights of this release
===================
- Many SciPy functions have gained native support for batching of N-dimensional
array input and additional support for the array API standard. An overall
summary of the latter is now available in a [set of tables](https://scipy.github.io/devdocs/dev/api-dev/array_api.html#api-coverage).
- In `scipy.sparse`, ``coo_array`` now has full support for indexing across
dimensions without needing to convert between sparse formats. ARPACK
and PROPACK rewrites from Fortran77 to C now empower the use of external
pseudorandom number generators.
- In `scipy.spatial`, ``transform.Rotation`` and ``transform.RigidTransform``
have been extended to support N-D arrays. ``geometric_slerp`` now has support
for extrapolation.
- `scipy.stats` has gained the matrix t and logistic distributions and many
performance and accuracy improvements.
- Initial support for 64-bit integer (ILP64) BLAS and LAPACK libraries has
been added, including for MKL, Apple Accelerate and OpenBLAS. Please
report any issues with ILP64 you encounter.

New features
===========

``scipy.integrate`` improvements
================================
- The integration routines ``dopri5``, ``dopri853``, ``LSODA``, ``vode``, and
``zvode`` have been ported from Fortran77 to C.
- `scipy.integrate.quad` now has a fast path for returning 0 when the integration
interval is empty.

``scipy.cluster`` improvements
==============================
- `scipy.cluster.hierarchy.is_isomorphic` has improved performance and array
API support.

``scipy.interpolate`` improvements
==================================
- A new ``bc_type`` argument has been added to `scipy.interpolate.make_splrep`
and `scipy.interpolate.make_splprep` to control the boundary conditions for
spline fitting. Allowed values are ``"not-a-knot"`` (default) and
``"periodic"``.
- A new ``derivative`` method has been added to the
`scipy.interpolate.NdBSpline` class, to construct a new spline representing a
partial derivative of the given spline. This method is similar to the
``BSpline.derivative`` method of 1-D spline objects.
- Performance of ``"cubic"`` and ``"quintic"`` modes of
`scipy.interpolate.RegularGridInterpolator` has been improved.
- Numerical stability of `scipy.interpolate.AAA` has been improved.
- `scipy.interpolate.FloaterHormannInterpolator` added support for
multidimensional, batched inputs and gained a new ``axis`` parameter to
select the interpolation axis.


``scipy.linalg`` improvements
=============================
- `scipy.linalg.inv` routine has been improved:

- it now attempts to detect the structure of its argument and selects an
 appropriate low-level matrix inversion routine. A new ``assume_a`` keyword
 allows to bypass the structure detection if the structure is known. For
 batched inputs, the detection is run for each 2D slice, unless an explicit
 value for ``assume_a`` is provided (in which case, the structure is
 assumed to be the same for all 2-D slices of the batch);
- the new ``lower={True,False}`` keyword argument has been added to help
 select the upper or lower triangle of the input matrix for symmetric
 inputs; refer to the docstring of `scipy.linalg.inv` for details;
- the routine emits a ``LinAlgWarning`` if it detects an ill-conditioned
 input;
- performance for batched inputs has been improved.
- `scipy.linalg.fiedler` has gained native support for batched inputs.
- performance has improved for `scipy.linalg.solve` with batched inputs
for certain matrix structures.

``scipy.optimize`` improvements
===============================
- ``optimize.minimize(method="trust-exact")`` now accepts a
solver-specific ``"subproblem_maxiter"`` option. This option can be used to
assure that the algorithm converges for functions with an ill-conditioned
Hessian.
- Callback functions used by ``optimize.minimize(method="slsqp")`` can
opt into the new callback interface by accepting a single keyword argument
``intermediate_result``.


``scipy.signal`` improvements
=============================
- `scipy.signal.abcd_normalize` gained more informative error messages and the
documentation was improved.
- `scipy.signal.get_window` now accepts the suffixes ``'_periodic'`` and
``'_symmetric'`` to distinguish between periodic and symmetric windows
(overriding the ``fftbin`` parameter). This benefits the functions
``coherence``, ``csd``, ``periodogram``, ``welch``, ``spectrogram``,
``stft``, ``istft``, ``resample``, ``resample_poly``, ``firwin``,
``firwin2``, ``firwin_2d``, ``check_COLA`` and ``check_NOLA``, which utilize
``get_window`` but do not expose the ``fftbin`` parameter.
- `scipy.signal.hilbert2` gained the new keyword ``axes`` for specifying the
axes along which the two-dimensional analytic signal should be calculated.
Furthermore, the documentation of `scipy.signal.hilbert` and
`scipy.signal.hilbert2` was significantly improved.


``scipy.sparse`` improvements
=============================
- ``coo_array`` now supports indexing. This includes slices, arrays,
``np.newaxis``, ``Ellipsis``, in 1D, 2D and the new nD. So COO format now
has full support for nD and COO now allows indexing without converting
formats.
- Additional sparse construction functions include ``expand_dims``,
``swapaxes``, ``permute_dims``, and nD support for the ``kron`` function.
- ARPACK Fortran77 library is ported to C. Among many changes, it is now
possible to use external random generators including NumPy PRNGs for
reproducible runs. Previously this was not the case due to internal seeding
behavior of the original ARPACK code.
- Similarly, PROPACK Fortran77 library is also ported to C with the same PRNG
enhancements and other improvements.
- `scipy.sparse.dok_array` now supports an ``update`` method which can be
used to update the sparse array using a dict, ``dict.items()``-like iterable,
or another ``dok_array`` matrix. It performs additional validation that keys
are valid index tuples.
- `scipy.sparse.dia_array.tocsr` is approximately three times faster and
some unneccesary copy operations have been removed from sparse format
interconversions more broadly.
- Added `scipy.sparse.linalg.funm_multiply_krylov`, a restarted Krylov method
for evaluating ``y = f(tA) b``.

``scipy.spatial`` improvements
==============================
- The ``spatial.transform`` module has gained an array API standard compatible
backend.
- ``transform.Rotation`` and ``transform.RigidTransform`` have been extended
from 0D single values and 1D arrays to N-D arrays, with standard indexing and
broadcasting rules. Both now have the following additions:

- A ``shape`` property.
- A ``shape`` argument to their ``identity()`` constructors, which should be
 preferred over the existing ``num`` argument. This has also been added as an
 argument for ``Rotation.random()`` (``RigidTransform`` does not currently
 have a ``random`` constructor).
- An ``axis`` argument to their ``mean()`` functions.

- The resulting shapes for ``transform.Rotation.from_euler`` /
``from_davenport`` have changed to make them consistent with broadcasting
rules. Angle inputs to Euler angles must now strictly match the number of
provided axes in the last dimension. The resulting ``Rotation`` has the shape
``np.atleast_1d(angles).shape[:-1]``. Angle inputs to Davenport angles must
also match the number of axes in the last dimension. The resulting ``Rotation``
has the shape ``np.broadcast_shapes(np.atleast_2d(axes).shape[:-2],
np.atleast_1d(angles).shape[:-1])``.
- ``Rotation.from_matrix`` has gained an ``assume_valid`` argument that allows for
performance improvements when users can guarantee valid matrix inputs.
``from_matrix`` is now also faster in cases where a known orthogonal matrix
is used.
- The `scipy.spatial.geometric_slerp` function can now extrapolate. When given a
value outside the range [0, 1], ``geometric_slerp()`` will continue with
the same rotation outside this range. For example, if spherically
interpolating with ``start`` being a point on the equator, and ``end``
being a point at the north pole, then a value of ``t=-1`` would give you a
point at the south pole.
- ``Rotation.as_euler`` and ``Rotation.as_davenport`` methods have gained a
``suppress_warnings`` parameter to enable suppression of gimbal lock warnings.

``scipy.special`` improvements
==============================
- The following functions for statistical applications have significantly
improved parameter ranges and reduced error rates: ``btdtria``, ``btdtrib``,
``chdtriv``, ``chndtr``, ``chndtrix``, ``chndtridf``, ``chndtrinc``, ``fdtr``,
``fdtrc``, ``fdtri``, ``gdtria``, ``gdtrix``, ``pdtrik``, ``stdtr`` and
``stdtrit``.
- The incomplete beta functions ``betainc``, ``betaincc``, ``betaincinv`` and
``betainccinv`` are improved for extreme parameter ranges.


``scipy.stats`` improvements
============================
- `scipy.stats.matrix_t` has been added to represent the matrix t distribution.
It supports methods ``pdf`` (and ``logpdf``) for computing the probability
density function and ``rvs`` for generating random variates.
- `scipy.stats.Logistic` was added for modeling random variables that follow a
logistic distribution.
- `scipy.stats.quantile` now accepts a ``weights`` argument to specify
frequency weights.
- `scipy.stats.quantile` is now faster on large arrays as it no longer uses
stable sort internally.
- `scipy.stats.quantile` supports three new values of the ``method`` argument,
``'round_inward'``, ``'round_outward'``, and ``'round_neareast'``, for use in
the context of trimming and winsorizing data.
- `scipy.stats.truncpareto` now accepts negative values for the exponent shape
parameter, enabling use of ``truncpareto`` as a more general power law
distribution.
- `scipy.stats.logser` now provides a distribution-specific implementation of
the ``sf`` method, improving speed and accuracy.
- Implementations of the following function have been vectorized:
`scipy.stats.ansari`, `scipy.stats.cramervonmises`,
`scipy.stats.cramervonmises_2samp`, `scipy.stats.epps_singleton_2samp`,
`scipy.stats.fligner`, `scipy.stats.friedmanchisquare`, `scipy.stats.kruskal`,
`scipy.stats.ks_1samp`, `scipy.stats.levene`, and `scipy.stats.mood`.
Typically, this improves performance with multidimensional (batch) input.
- The critical value tables of `scipy.stats.anderson` have been updated.
- The speed and accuracy of most `scipy.stats.zipfian` methods has been
improved.
- The accuracies of the `scipy.stats.Binomial` methods ``logcdf`` and
``logccdf`` have been improved in the tails.
- The default guess of ``scipy.stats.trapezoid.fit`` has been improved.
- The accuracy and range of the ``cdf``, ``sf``, ``isf``, and ``ppf`` methods
of `scipy.stats.binom` and `scipy.stats.nbinom` has been improved.


Array API Standard Support
=====================
- An overall summary table for our array API standard support/coverage is [now available](https://scipy.github.io/devdocs/dev/api-dev/array_api.html#api-coverage)
- The overhead associated with array namespace determination has been reduced,
providing improved performance in dispatching to different backends.
- `scipy.cluster.hierarchy.is_isomorphic` has gained support.
- `scipy.interpolate.make_lsq_spline`, `scipy.interpolate.make_smoothing_spline`,
`scipy.interpolate.make_splrep`, `scipy.interpolate.make_splprep`,
`scipy.interpolate.generate_knots`, and `scipy.interpolate.make_interp_spline`
have gained support.
- `scipy.signal.bilinear`, `scipy.signal.iircomb`, `scipy.signal.iirdesign`,
`scipy.signal.iirfilter`, `scipy.signal.iirpeak`, `scipy.signal.iirnotch`,
`scipy.signal.gammatone`, and `scipy.signal.group_delay` have gained support.
- `scipy.signal.butter`, `scipy.signal.buttap`, `scipy.signal.buttord`,
`scipy.signal.cheby1`, `scipy.signal.cheb1ap`, `scipy.signal.cheb1ord`,
`scipy.signal.cheby2`, `scipy.signal.cheb2ap`, `scipy.signal.cheb2ord`,
`scipy.signal.bessel`, `scipy.signal.besselap`, `scipy.signal.ellip`,
`scipy.signal.ellipap`, and `scipy.signal.ellipord` have gained support.
- `scipy.signal.savgol_filter`, `scipy.signal.savgol_coeffs`, and
`scipy.signal.abcd_normalize` have gained support.
- ``spatial.transform`` has gained support.
- `scipy.integrate.qmc_quad`, `scipy.integrate.cumulative_simpson`,
`scipy.integrate.cumulative_trapezoid`, and `scipy.integrate.romb` have
gained support.
- `scipy.linalg.block_diag`, `scipy.linalg.fiedler`, and
`scipy.linalg.orthogonal_procrustes` have gained support.
- `scipy.interpolate.BSpline`, `scipy.interpolate.NdBSpline`,
`scipy.interpolate.RegularGridInterpolator`, and
`scipy.interpolate.RBFInterpolator` gained support.
- Support added for `scipy.stats.alexandergovern`, `scipy.stats.bootstrap`,
`scipy.stats.brunnermunzel`, `scipy.stats.chatterjeexi`,
`scipy.stats.cramervonmises`, `scipy.stats.cramervonmises_2samp`,
`scipy.stats.epps_singleton_2samp`, `scipy.stats.false_discovery_control`,
`scipy.stats.fligner`, `scipy.stats.friedmanchisquare`, `scipy.stats.iqr`,
`scipy.stats.kruskal`, `scipy.stats.ks_1samp`, `scipy.stats.levene`,
`scipy.stats.lmoment`, `scipy.stats.mannwhitneyu`,
`scipy.stats.median_abs_deviation`, `scipy.stats.mode`, `scipy.stats.mood`,
`scipy.stats.ansari`,
`scipy.stats.power`, `scipy.stats.permutation_test`, `scipy.stats.sigmaclip`,
`scipy.stats.wilcoxon`, and `scipy.stats.yeojohnson_llf`.
- `scipy.stats.pearsonr` has gained support for JAX and Dask backends.
- `scipy.stats.variation` has gained support for the Dask backend.
- ``marray`` support was added for ``stats.gtstd``, ``stats.directional_stats``,
``stats.bartlett``, ``stats.variation``, ``stats.pearsonr``, and
``stats.entropy``.

Deprecated features and future changes
===============================
- The `scipy.odr` module is deprecated in v1.17.0 and will be completely
removed in v1.19.0. Users are suggested to use the ``odrpack`` package instead.
- The default dype behavior of `scipy.sparse.diags` and
`scipy.sparse.diags_array` will change in v1.19.0.
- In v1.19.0, `scipy.linalg.hankel` will no longer ravel multidimensional
inputs and instead will treat them as a batch.
- The ``precenter`` argument of `scipy.signal.lombscargle` is deprecated and
will be removed in v1.19.0. Furthermore, some arguments will become keyword
only.


Expired deprecations
================
- ``scipy.stats.find_repeats`` has been removed. Please use
``numpy.unique``/``numpy.unique_counts`` instead.
- `scipy.linalg` functions for Toeplitz matrices no longer ravel n-d input
arguments; instead, multidimensional input is treated as a batch.
- The ``seed`` and ``rand`` functions from `scipy.linalg.interpolative` have
been removed. Use the ``rng`` argument instead.
- Complex inputs to `scipy.spatial.distance.cosine` and
`scipy.spatial.distance.correlation` now raise an error.
- Support for object arrays and longdoubles has been removed from
`scipy.signal.correlate`, `scipy.signal.convolve`, `scipy.signal.lfilter`,
and `scipy.signal.sosfilt`.
- ``kulczynski1`` and ``sokalmichener`` have been removed from
`scipy.spatial.distance`.
- ``kron`` has been removed from `scipy.linalg`. Please use ``numpy.kron``.
- Accidentally exposed functions have been removed from
``scipy.interpolate.interpnd``.
- The ``random_state`` and ``permutation`` arguments of
`scipy.stats.ttest_ind` have been removed.
- ``sph_harm``, ``clpmn``, ``lpn``, and ``lpmn`` have been removed from
`scipy.special`.


Backwards incompatible changes
=========================
- The resulting shapes for ``transform.Rotation.from_euler`` /
``from_davenport`` have changed to make them consistent with broadcasting
rules. Angle inputs to Euler angles must now strictly match the number of
provided axes in the last dimension. The resulting ``Rotation`` has the shape
``np.atleast_1d(angles).shape[:-1]``. Angle inputs to Davenport angles must
also match the number of axes in the last dimension. The resulting ``Rotation``
has the shape ``np.broadcast_shapes(np.atleast_2d(axes).shape[:-2],
np.atleast_1d(angles).shape[:-1])``.

Other changes
===========
- The version of the Boost Math library leveraged by SciPy has been
increased from ``1.88.0`` to ``1.89.0``.
- On POSIX operating systems, SciPy will now use the ``'forkserver'``
multiprocessing context on Python 3.13 and older for ``workers=<an-int>``
calls if the user hasn't configured a default method themselves. This follows
the default behavior on Python 3.14.
- Initial support for 64-bit integer (ILP64) BLAS and LAPACK libraries has been
added. To enable it, build SciPy with ``-Duse-ilp64=true`` meson option, and make
sure to have a LAPACK library which exposes both LP64 and ILP64 symbols.
Currently supported LAPACK libraries are MKL, Apple Accelerate and OpenBLAS
through the ``scipy-openblas64`` package. Note that:

- the ILP64 support is optional, and is in addition to the always-available
 LP64 interface;
- at runtime, you can select the ILP64 variants via the
 ``get_{blas,lapack}_funcs`` functions:
 ``scipy.linalg.lapack.get_lapack_funcs(..., use_ilp64="preferred")`` selects
 the ILP64 variant if available and LP64 variant otherwise;
- ``cython_blas`` and ``cython_lapack`` modules always contain the LP64
 routines for ABI compatibility.

Please report any issues with ILP64 you encounter.

Authors
======

* Name (commits)
* h-vetinari (3)
* Joshua Alexander (1) +
* Amit Aronovitch (1) +
* Ayush Baranwal (1) +
* Cristrian Batrin (1) +
* Marco Berzborn (1) +
* Ole Bialas (1) +
* Om Biradar (1) +
* Florian Bourgey (1)
* Jake Bowhay (102)
* Matteo Brivio (1) +
* Dietrich Brunn (34)
* Johannes Buchner (2) +
* Evgeni Burovski (288)
* Nicholas Carlini (1) +
* Luca Cerina (1) +
* Christine P. Chai (35)
* Saransh Chopra (1)
* Lucas Colley (117)
* Björn Ingvar Dahlgren (2) +
* Sumit Das (1) +
* Hans Dembinski (1)
* John M Dusel (1) +
* DWesl (4)
* Pieter Eendebak (6)
* Kian Eliasi (2)
* Rob Falck (1)
* Abdullah Fayed (3) +
* Emmanuel Ferdman (2) +
* Filipe Laíns (1) +
* Daniel Fremont (1) +
* Neil Girdhar (1)
* Ilan Gold (35)
* Nathan Goldbaum (3) +
* Ralf Gommers (121)
* Nicolas Guidotti (1) +
* Geoffrey Gunter (1) +
* Matt Haberland (177)
* Joren Hammudoglu (56)
* Jacob Hass (2) +
* Nick Hodgskin (1) +
* Stephen Huan (1) +
* Guido Imperiale (41)
* Gert-Ludwig Ingold (1)
* Jaime Rodríguez-Guerra (2) +
* JBlitzar (1) +
* Adam Jones (2)
* Dustin Kenefake (1) +
* Robert Kern (3)
* Gleb Khmyznikov (1) +
* Daniil Kiktenko (1) +
* Pascal Klein (2) +
* kleiter (1) +
* Oliver Kovacs (1) +
* Koven (1) +
* Abhishek Kumar (2) +
* Arthur Lacote (2) +
* Eric Larson (7)
* Mouad Leachouri (1) +
* Tristan Leclercq (1) +
* Antony Lee (5)
* Jesse Livezey (8)
* Philip Loche (1)
* Yuxi Long (4) +
* Christian Lorentzen (1)
* Joshua Markovic (1) +
* Gabryel Mason-Williams (1) +
* mcdigman (1) +
* Rafael Menezes (1) +
* Stefano Miccoli (1) +
* Michał Górny (2)
* Jost Migenda (7) +
* Suriyaa MM (1) +
* Andrew Nelson (72)
* newyork_loki (2) +
* Nick ODell (33)
* Dimitri Papadopoulos Orfanos (2)
* Drew Parsons (1)
* Gilles Peiffer (3) +
* Matti Picus (1)
* Jonas Pleyer (2) +
* Ilhan Polat (116)
* Akshay Priyadarshi (2) +
* Mohammed Abdul Rahman (1) +
* Daniele Raimondi (2) +
* Ritesh Rana (1) +
* Adrian Raso (1) +
* Dan Raviv (1) +
* Tyler Reddy (116)
* Lucas Roberts (4)
* Bernard Roesler (1) +
* Mikhail Ryazanov (27)
* Jaro Schmidt (1) +
* Daniel Schmitz (25)
* Martin Schuck (25)
* Dan Schult (29)
* Mugunthan Selvanayagam (1) +
* Scott Shambaugh (14)
* Rodrigo Silva (1) +
* Samaresh Kumar Singh (8) +
* Kartik Sirohi (1) +
* Albert Steppi (178)
* Matthias Straka (1) +
* Theo Teske (1) +
* Noam Teyssier (1) +
* tommie979 (1) +
* Christian Veenhuis (1)
* Pierre Veron (1) +
* Shuhei Watanabe (1) +
* Warren Weckesser (25)
* WhimsyHippo (7) +
* Rory Yorke (2)
* Will Zhang (1) +
* Eric Zitong Zhou (1)
* Tingwei Zhu (1) +
* Zhenyu Zhu (1) +
* ਗਗਨਦੀਪ ਸਿੰਘ (Gagandeep Singh) (38)

A total of 117 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

The full issue and pull request lists, and the release asset hashes are available
in the associated `README.txt` file.

1.16.3

====================

SciPy `1.16.3` is a bug-fix release with no new features compared to `1.16.2`.

Authors
=======
* Name (commits)
* ChrisAB (1) +
* Lucas Colley (1)
* Ralf Gommers (3)
* Matt Haberland (8)
* Nick ODell (2)
* Ilhan Polat (1)
* Tyler Reddy (28)
* Lucas Roberts (2)

A total of 8 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

The full issue and pull request lists, and the release asset hashes are available
in the associated `README.txt` file.

1.16.2

compared to `1.16.1`. This is the first stable release of
SciPy to provide Windows on ARM wheels on PyPI.



Authors
=======
* Name (commits)
* Dietrich Brunn (1)
* Ralf Gommers (6)
* Adam Jones (1)
* Gleb Khmyznikov (1) +
* Jost Migenda (1) +
* newyork_loki (1)
* Nick ODell (3)
* Dimitri Papadopoulos Orfanos (1)
* Ilhan Polat (2)
* Tyler Reddy (26)
* Mugunthan Selvanayagam (1) +
* Shuhei Watanabe (1) +

A total of 12 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

The full issue and pull request lists, and the release asset hashes are available
in the associated `README.txt` file.

1.16.1

====================

SciPy `1.16.1` is a bug-fix release that adds support for Python `3.14.0rc1`,
including PyPI wheels.

Authors
=======
* Name (commits)
* Evgeni Burovski (1)
* Rob Falck (1)
* Ralf Gommers (7)
* Geoffrey Gunter (1) +
* Matt Haberland (2)
* Joren Hammudoglu (1)
* Andrew Nelson (2)
* newyork_loki (1) +
* Ilhan Polat (1)
* Tyler Reddy (25)
* Daniel Schmitz (1)
* Dan Schult (2)

A total of 12 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

The full issue and pull request lists, and the release asset hashes are available
in the associated `README.txt` file.

1.16.0

many new features, numerous bug-fixes, improved test coverage and better
documentation. There have been a number of deprecations and API changes
in this release, which are documented below. All users are encouraged to
upgrade to this release, as there are a large number of bug-fixes and
optimizations. Before upgrading, we recommend that users check that
their own code does not use deprecated SciPy functionality (to do so,
run your code with ``python -Wd`` and check for ``DeprecationWarning`` s).
Our development attention will now shift to bug-fix releases on the
1.16.x branch, and on adding new features on the main branch.

This release requires Python `3.11-3.13` and NumPy `1.25.2` or greater.


Highlights of this release
==================

- Improved experimental support for the Python array API standard, including
new support in `scipy.signal`, and additional support in `scipy.stats` and
`scipy.special`. Improved support for JAX and Dask backends has been added,
with notable support in `scipy.cluster.hierarchy`, many functions in
`scipy.special`, and many of the trimmed statistics functions.
- `scipy.optimize` now uses the new Python implementation from the
[`PRIMA`](https://www.libprima.net) package for COBYLA. The PRIMA implementation [fixes many bugs](https://github.com/libprima/prima#bug-fixes)
in the old Fortran 77 implementation with [a better performance on average](https://github.com/libprima/prima#improvements).
- `scipy.sparse.coo_array` now supports n-D arrays with reshaping, arithmetic and
reduction operations like sum/mean/min/max. No n-D indexing or
`scipy.sparse.random_array` support yet.
- Updated guide and tools for migration from sparse matrices to sparse arrays.
- All functions in the `scipy.linalg` namespace that accept array arguments
now support N-dimensional arrays to be processed as a batch.
- Two new `scipy.signal` functions, `scipy.signal.firwin_2d` and
`scipy.signal.closest_STFT_dual_window`, for creation of a 2-D FIR filter and
`scipy.signal.ShortTimeFFT` dual window calculation, respectively.
- A new class, `scipy.spatial.transform.RigidTransform`, provides functionality
to convert between different representations of rigid transforms in 3-D
space.


New features
==========

``scipy.io`` improvements
=========================
- `scipy.io.savemat` now provides informative warnings for invalid field names.
- `scipy.io.mmread` now provides a clearer error message when provided with
a source file path that does not exist.
- `scipy.io.wavfile.read` can now read non-seekable files.


``scipy.integrate`` improvements
================================
- The error estimate of `scipy.integrate.tanhsinh` was improved.


``scipy.interpolate`` improvements
==================================
- Batch support was added to `scipy.interpolate.make_smoothing_spline`.


``scipy.linalg`` improvements
=============================
- All functions in the `scipy.linalg` namespace that accept array arguments
now support N-dimensional arrays to be processed as a batch.
See :ref:`linalg_batch` for details.
- `scipy.linalg.sqrtm` is rewritten in C and its performance is improved. It
also tries harder to return real-valued results for real-valued inputs if
possible. See the function docstring for more details. In this version the
input argument ``disp`` and the optional output argument ``errest`` are
deprecated and will be removed four versions later. Similarly, after
changing the underlying algorithm to recursion, the ``blocksize`` keyword
argument has no effect and will be removed two versions later.
- Wrappers for ``?stevd``, ``?langb``, ``?sytri``, ``?hetri`` and
``?gbcon`` were added to `scipy.linalg.lapack`.
- The default driver of `scipy.linalg.eigh_tridiagonal` was improved.
- `scipy.linalg.solve` can now estimate the reciprocal condition number and
the matrix norm calculation is more efficient.


``scipy.ndimage`` improvements
==============================
- A new function `scipy.ndimage.vectorized_filter` for generic filters that
take advantage of a vectorized Python callable was added.
- `scipy.ndimage.rotate` has improved performance, especially on ARM platforms.


``scipy.optimize`` improvements
===============================
- COBYLA was updated to use the new Python implementation from the [PRIMA](https://www.libprima.net) package. 
The PRIMA implementation [fixes many bugs](https://github.com/libprima/prima#bug-fixes>) 
in the old Fortran 77 implementation. In addition, it results in [fewer function evaluations on average](https://github.com/libprima/prima#improvements),
but it depends on the problem and for some
problems it can result in more function evaluations or a less optimal
result. For those cases the user can try modifying the initial and final
trust region radii given by ``rhobeg`` and ``tol`` respectively. A larger
``rhobeg`` can help the algorithm take bigger steps initially, while a
smaller ``tol`` can help it continue and find a better solution.
For more information, see the [PRIMA documentation](https://www.libprima.net).
- Several of the `scipy.optimize.minimize` methods, and the
`scipy.optimize.least_squares` function, have been given a ``workers``
keyword. This allows parallelization of some calculations via a map-like
callable, such as ``multiprocessing.Pool``. These parallelization
opportunities typically occur during numerical differentiation. This can
greatly speed up minimization when the objective function is expensive to
calculate.
- The ``lm`` method of `scipy.optimize.least_squares` can now accept
``3-point`` and ``cs`` for the ``jac`` keyword.
- The SLSQP Fortran 77 code was ported to C. When this method is used now the
constraint multipliers are exposed to the user through the ``multiplier``
keyword of the returned `scipy.optimize.OptimizeResult` object.
- NNLS code has been corrected and rewritten in C to address the performance
regression introduced in 1.15.x
- `scipy.optimize.root` now warns for invalid inner parameters when using the
``newton_krylov`` method
- The return value of minimization with ``method='L-BFGS-B'`` now has
a faster ``hess_inv.todense()`` implementation. Time complexity has improved
from cubic to quadratic.
- `scipy.optimize.least_squares` has a new ``callback`` argument that is applicable
to the ``trf`` and ``dogbox`` methods. ``callback`` may be used to track
optimization results at each step or to provide custom conditions for
stopping.


``scipy.signal`` improvements
=============================
- A new function `scipy.signal.firwin_2d` for the creation of a 2-D FIR Filter
using the 1-D window method was added.
- `scipy.signal.cspline1d_eval` and `scipy.signal.qspline1d_eval` now provide
an informative error on empty input rather than hitting the recursion limit.
- A new function `scipy.signal.closest_STFT_dual_window` to calculate the
`~scipy.signal.ShortTimeFFT` dual window of a given window closest to a
desired dual window.
- A new classmethod `scipy.signal.ShortTimeFFT.from_win_equals_dual` to
create a `~scipy.signal.ShortTimeFFT` instance where the window and its dual
are equal up to a scaling factor. It allows to create short-time Fourier
transforms which are unitary mappings.
- The performance of `scipy.signal.convolve2d` was improved.


``scipy.sparse`` improvements
=============================
- `scipy.sparse.coo_array` now supports n-D arrays using binary and reduction
operations.
- Faster operations between two DIA arrays/matrices for: add, sub, multiply,
matmul.
- `scipy.sparse.csgraph.dijkstra` shortest_path is more efficient.
- `scipy.sparse.csgraph.yen` has performance improvements.
- Support for lazy loading of ``sparse.csgraph`` and ``sparse.linalg`` was
added.


``scipy.spatial`` improvements
==============================
- A new class, `scipy.spatial.transform.RigidTransform`, provides functionality
to convert between different representations of rigid transforms in 3-D
space, its application to vectors and transform composition.
It follows the same design approach as `scipy.spatial.transform.Rotation`.
- `scipy.spatial.transform.Rotation` now has an appropriate ``__repr__`` method,
and improved performance for its `scipy.spatial.transform.Rotation.apply`
method.


``scipy.stats`` improvements
============================
- A new function `scipy.stats.quantile`, an array API compatible function for
quantile estimation, was added.
- `scipy.stats.make_distribution` was extended to work with existing discrete
distributions and to facilitate the creation of custom distributions in the
new random variable infrastructure.
- A new distribution, `scipy.stats.Binomial`, was added.
- An ``equal_var`` keyword was added to `scipy.stats.tukey_hsd` (enables the
Games-Howell test) and `scipy.stats.f_oneway` (enables Welch ANOVA).
- The moment calculation for `scipy.stats.gennorm` was improved.
- The `scipy.stats.mode` implementation was vectorized, for faster batch
calculation.
- Support for ``axis``, ``nan_policy``, and ``keepdims`` keywords was added to
`scipy.stats.power_divergence`, `scipy.stats.chisquare`,
`scipy.stats.pointbiserialr`, `scipy.stats.kendalltau`,
`scipy.stats.weightedtau`, `scipy.stats.theilslopes`,
`scipy.stats.siegelslopes`, and `scipy.stats.boxcox_llf`.
- The performance of `scipy.stats.special_ortho_group` and `scipy.stats.pearsonr`
was improved.


Array API Standard Support
=====================

Experimental support for array libraries other than NumPy has been added to
multiple submodules in recent versions of SciPy. Please consider testing
these features by setting the environment variable ``SCIPY_ARRAY_API=1`` and
providing PyTorch, JAX, CuPy or Dask arrays as array arguments.

Many functions in `scipy.stats`, `scipy.special`, `scipy.optimize`, and
`scipy.constants` now provide tables documenting compatible array and device
types as well as support for lazy arrays and JIT compilation. New features with
support and old features with support added for SciPy 1.16.0 include:

- Most of the `scipy.signal` functionality
- `scipy.ndimage.vectorized_filter`
- `scipy.special.stdtrit`
- `scipy.special.softmax`
- `scipy.special.log_softmax`
- `scipy.stats.quantile`
- `scipy.stats.gstd`
- `scipy.stats.rankdata`

Features with extended array API support (generally, improved support
for JAX and Dask) in SciPy 1.16.0 include:

- many of the `scipy.cluster.hierarchy` functions
- many functions in `scipy.special`
- many of the trimmed statistics functions in `scipy.stats`

SciPy now has a CI job that exercises GPU (CUDA) support, and as a result
using PyTorch, CuPy or JAX arrays on GPU with SciPy is now more reliable.


Deprecated features
================
- The unused ``atol`` argument of `scipy.optimize.nnls` is deprecated and will
be removed in SciPy 1.18.0.
- The ``disp`` argument of `scipy.linalg.signm`, `scipy.linalg.logm`, and
`scipy.linalg.sqrtm` will be removed in SciPy 1.18.0.
- `scipy.stats.multinomial` now emits a ``FutureWarning`` if the rows of ``p``
do not sum to ``1.0``. This condition will produce NaNs beginning in SciPy
1.18.0.

Expired Deprecations
=================
- ``scipy.sparse.conjtransp`` has been removed. Use ``.T.conj()`` instead.
- The ``quadrature='trapz'`` option has been removed from
`scipy.integrate.quad_vec`, and ``scipy.stats.trapz`` has been removed. Use
``trapezoid`` in both instances instead.
- `scipy.special.comb` and `scipy.special.perm` now raise when ``exact=True``
and arguments are non-integral.
- Support for inference of the two sets of measurements from the single
argument ``x`` has been removed from `scipy.stats.linregress`. The data
must be specified separately as ``x`` and ``y``.
- Support for NumPy masked arrays has been removed from
`scipy.stats.power_divergence` and `scipy.stats.chisquare`.



Backwards incompatible changes
==========================
- Several of the `scipy.linalg` functions for solving a linear system (e.g.
`scipy.linalg.solve`) documented that the RHS argument must be either 1-D or
2-D but did not always raise an error when the RHS argument had more the
two dimensions. Now, many-dimensional right hand sides are treated according
to the rules specified in :ref:`linalg_batch`.
- `scipy.stats.bootstrap` now explicitly broadcasts elements of ``data`` to the
same shape (ignoring ``axis``) before performing the calculation.


Build and packaging related changes
============================
- The minimum supported version of Clang was bumped from 12.0 to 15.0.
- The lowest supported macOS version for wheels on PyPI is now 10.14 instead of
10.13.
- The sdist contents were optimized, resulting in a size reduction of about 50%,
from 60 MB to 30 MB.
- For ``Cython>=3.1.0``, SciPy now uses the new ``cython --generate-shared``
functionality, which reduces the total size of SciPy's wheels and on-disk
installations significantly.
- SciPy no longer contains an internal shared library that requires RPATH support,
after ``sf_error_state`` was removed from `scipy.special`.
- A new build option ``-Duse-system-libraries`` has been added. It allows
opting in to using system libraries instead of using vendored sources.
Currently ``Boost.Math`` and ``Qhull`` are supported as system build
dependencies.


Other changes
===========
- The internal dependency of ``scipy._lib`` on ``scipy.sparse`` was removed,
which reduces the import time of a number of other SciPy submodules.
- Support for free-threaded CPython was improved: the last known thread-safety
issues in `scipy.special` were fixed, and ``pytest-run-parallel`` is now used
in a CI job to guard against regressions.
- Support for [`spin`](https://github.com/scientific-python/spin) as a developer
CLI was added, including support for editable installs. The SciPy-specific
``python dev.py`` CLI will be removed in the next release cycle in favor of
``spin``.
- The vendored Qhull library was upgraded from version 2019.1 to 2020.2.
- A large amount of the C++ code in ``scipy.special`` was moved to the new
header-only [`xsf`](https://github.com/scipy/xsf) library. That library was
included back in the SciPy source tree as a git submodule.
- The ``namedtuple``-like bunch objects returned by some SciPy functions
now have improved compatibility with the ``polars`` library.
- The output of the ``rvs`` method of `scipy.stats.wrapcauchy` is now mapped to
the unit circle between 0 and ``2 * pi``.
- The ``lm`` method of `scipy.optimize.least_squares` now has a different behavior
for the maximum number of function evaluations, ``max_nfev``. The default for
the ``lm`` method is changed to ``100 * n``, for both a callable and a
numerically estimated jacobian. This limit on function evaluations excludes
those used for any numerical estimation of the Jacobian. Previously the
default when using an estimated jacobian was ``100 * n * (n + 1)``, because
the method included evaluations used in the estimation. In addition, for the
``lm`` method the number of function calls used in Jacobian approximation
is no longer included in ``OptimizeResult.nfev``. This brings the behavior
of ``lm``, ``trf``, and ``dogbox`` into line.


Authors
======

* Name (commits)
* h-vetinari (4)
* aiudirog (1) +
* Anton Akhmerov (2)
* Thorsten Alteholz (1) +
* Gabriel Augusto (1) +
* Backfisch263 (1) +
* Nickolai Belakovski (5)
* Peter Bell (1)
* Benoît W. (1) +
* Evandro Bernardes (1)
* Gauthier Berthomieu (1) +
* Maxwell Bileschi (1) +
* Sam Birch (1) +
* Florian Bourgey (3) +
* Charles Bousseau (2) +
* Richard Strong Bowen (2) +
* Jake Bowhay (126)
* Matthew Brett (1)
* Dietrich Brunn (52)
* Evgeni Burovski (252)
* Christine P. Chai (12) +
* Gayatri Chakkithara (1) +
* Saransh Chopra (2) +
* Omer Cohen (1) +
* Lucas Colley (91)
* Yahya Darman (3) +
* Benjamin Eisele (1) +
* Donnie Erb (1)
* Sagi Ezri (58) +
* Alexander Fabisch (2) +
* Matthew H Flamm (1)
* Karthik Viswanath Ganti (1) +
* Neil Girdhar (1)
* Ralf Gommers (153)
* Rohit Goswami (4)
* Saarthak Gupta (4) +
* Matt Haberland (320)
* Sasha Hafner (1) +
* Joren Hammudoglu (9)
* Chengyu Han (1) +
* Charles Harris (1)
* Kim Hsieh (4) +
* Yongcai Huang (2) +
* Lukas Huber (1) +
* Yuji Ikeda (2) +
* Guido Imperiale (103) +
* Robert Kern (2)
* Harin Khakhi (2) +
* Agriya Khetarpal (4)
* Kirill R. (2) +
* Tetsuo Koyama (1)
* Jigyasu Krishnan (1) +
* Pratham Kumar (3) +
* David Kun (1) +
* Eric Larson (3)
* lciti (1)
* Antony Lee (1)
* Kieran Leschinski (1) +
* Thomas Li (2) +
* Christian Lorentzen (2)
* Loïc Estève (4)
* Panos Mavrogiorgos (1) +
* Nikolay Mayorov (2)
* Melissa Weber Mendonça (10)
* Miguel Cárdenas (2) +
* Swastik Mishra (1) +
* Sturla Molden (2)
* Andreas Nazlidis (1) +
* Andrew Nelson (209)
* Parth Nobel (1) +
* Nick ODell (9)
* Giacomo Petrillo (1)
* Victor PM (10) +
* pmav99 (1) +
* Ilhan Polat (73)
* Tyler Reddy (66)
* Érico Nogueira Rolim (1) +
* Pamphile Roy (10)
* Mikhail Ryazanov (6)
* Atsushi Sakai (9)
* Marco Salathe (1) +
* sanvi (1) +
* Neil Schemenauer (2) +
* Daniel Schmitz (20)
* Martin Schuck (1) +
* Dan Schult (32)
* Tomer Sery (19)
* Adrian Seyboldt (1) +
* Scott Shambaugh (4)
* ShannonS00 (1) +
* sildater (3) +
* Param Singh (1) +
* G Sreeja (7) +
* Albert Steppi (133)
* Kai Striega (3)
* Anushka Suyal (2)
* Julia Tatz (1) +
* Tearyt (1) +
* Elia Tomasi (1) +
* Jamie Townsend (2) +
* Edgar Andrés Margffoy Tuay (4)
* Matthias Urlichs (1) +
* Mark van Rossum (1) +
* Jacob Vanderplas (2)
* David Varela (2) +
* Christian Veenhuis (3)
* vfdev (1)
* Stefan van der Walt (2)
* Warren Weckesser (5)
* Jason N. White (1) +
* windows-server-2003 (5)
* Zhiqing Xiao (1)
* Pavadol Yamsiri (1)
* Rory Yorke (3)
* Irwin Zaid (4)
* Austin Zhang (1) +
* William Zijie Zhang (1) +
* Zaikun Zhang (1) +
* Eric Zitong Zhou (11) +
* Case Zumbrum (2) +
* ਗਗਨਦੀਪ ਸਿੰਘ (Gagandeep Singh) (45)

A total of 121 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

Full issue and PR lists are available in the `README.txt` release artifact.

1.15.3

compared to `1.15.2`.

For the complete issue and PR lists see the [raw release notes](https://github.com/scipy/scipy/releases/download/v1.15.3/README.txt).

Authors
=======
* Name (commits)
* aiudirog (1) +
* Nickolai Belakovski (1)
* Florian Bourgey (1) +
* Richard Strong Bowen (2) +
* Jake Bowhay (1)
* Dietrich Brunn (2)
* Evgeni Burovski (1)
* Lucas Colley (1)
* Ralf Gommers (1)
* Saarthak Gupta (1) +
* Matt Haberland (4)
* Chengyu Han (1) +
* Lukas Huber (1) +
* Nick ODell (2)
* Ilhan Polat (4)
* Tyler Reddy (52)
* Neil Schemenauer (1) +
* Dan Schult (1)
* sildater (1) +
* Gagandeep Singh (4)
* Albert Steppi (2)
* Matthias Urlichs (1) +
* David Varela (1) +
* ਗਗਨਦੀਪ ਸਿੰਘ (Gagandeep Singh) (3)

A total of 24 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

1.15.2

compared to `1.15.1`. Free-threaded Python `3.13` wheels
for Linux ARM platform are available on PyPI starting with
this release.


Authors
=======
* Name (commits)
* Peter Bell (1)
* Charles Bousseau (1) +
* Jake Bowhay (3)
* Matthew Brett (1)
* Ralf Gommers (3)
* Rohit Goswami (1)
* Matt Haberland (4)
* Parth Nobel (1) +
* Tyler Reddy (33)
* Daniel Schmitz (2)
* Dan Schult (5)
* Scott Shambaugh (2)
* Edgar Andrés Margffoy Tuay (1)
* Warren Weckesser (4)

A total of 14 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

1.15.1

compared to `1.15.0`. Importantly, an issue with the
import of `scipy.optimize` breaking other packages
has been fixed.



Authors
=======
* Name (commits)
* Ralf Gommers (3)
* Rohit Goswami (1)
* Matt Haberland (2)
* Tyler Reddy (7)
* Daniel Schmitz (1)

A total of 5 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

1.15

3.13.`` This allows SciPy functionality to execute in parallel with Python
threads
(see the ``threading`` stdlib module). This support was enabled by fixing a
significant number of thread-safety issues in both pure Python and
C/C++/Cython/Fortran extension modules. Wheels are provided on PyPI for this
release; NumPy ``>=2.1.3`` is required at runtime. Note that building for a
free-threaded interpreter requires a recent pre-release or nightly for Cython
``3.1.0``.

Support for free-threaded Python does not mean that SciPy is fully thread-safe.
Please see :ref:`scipy_thread_safety` for more details.

If you are interested in free-threaded Python, for example because you have a
multiprocessing-based workflow that you are interested in running with Python
threads, we encourage testing and experimentation. If you run into problems
that you suspect are because of SciPy, please open an issue, checking first if
the bug also occurs in the "regular" non-free-threaded CPython ``3.13`` build.
Many threading bugs can also occur in code that releases the GIL; disabling
the GIL only makes it easier to hit threading bugs.


Array API Standard Support
=====================
Experimental support for array libraries other than NumPy has been added to
existing sub-packages in recent versions of SciPy. Please consider testing
these features by setting an environment variable ``SCIPY_ARRAY_API=1`` and
providing PyTorch, JAX, ndonnx, or CuPy arrays as array arguments. Features
with support added for SciPy ``1.15.0`` include:

- All functions in `scipy.differentiate` (new sub-package)
- All functions in `scipy.optimize.elementwise` (new namespace)
- `scipy.optimize.rosen`, `scipy.optimize.rosen_der`, and
`scipy.optimize.rosen_hess`
- `scipy.special.logsumexp`
- `scipy.integrate.trapezoid`
- `scipy.integrate.tanhsinh` (newly public function)
- `scipy.integrate.cubature` (new function)
- `scipy.integrate.nsum` (new function)
- `scipy.special.chdtr`, `scipy.special.betainc`, and `scipy.special.betaincc`
- `scipy.stats.boxcox_llf`
- `scipy.stats.differential_entropy`
- `scipy.stats.zmap`, `scipy.stats.zscore`, and `scipy.stats.gzscore`
- `scipy.stats.tmean`, `scipy.stats.tvar`, `scipy.stats.tstd`,
`scipy.stats.tsem`, `scipy.stats.tmin`, and `scipy.stats.tmax`
- `scipy.stats.gmean`, `scipy.stats.hmean` and `scipy.stats.pmean`
- `scipy.stats.combine_pvalues`
- `scipy.stats.ttest_ind`, `scipy.stats.ttest_rel`
- `scipy.stats.directional_stats`
- `scipy.ndimage` functions will now delegate to ``cupyx.scipy.ndimage``,
and for other backends will transit via NumPy arrays on the host.



Deprecated features
================
- Functions `scipy.linalg.interpolative.rand` and
`scipy.linalg.interpolative.seed` have been deprecated and will be removed
in SciPy ``1.17.0``.
- Complex inputs to `scipy.spatial.distance.cosine` and
`scipy.spatial.distance.correlation` have been deprecated and will raise
an error in SciPy ``1.17.0``.
- `scipy.spatial.distance.kulczynski1` and
`scipy.spatial.distance.sokalmichener` were deprecated and will be removed
in SciPy ``1.17.0``.
- `scipy.stats.find_repeats` is deprecated as of SciPy ``1.15.0`` and will be
removed in SciPy ``1.17.0``. Please use
``numpy.unique``/``numpy.unique_counts`` instead.
- `scipy.linalg.kron` is deprecated in favour of ``numpy.kron``.
- Using object arrays and longdouble arrays in `scipy.signal`
convolution/correlation functions (`scipy.signal.correlate`,
`scipy.signal.convolve` and `scipy.signal.choose_conv_method`) and
filtering functions (`scipy.signal.lfilter`, `scipy.signal.sosfilt`) has
been deprecated as of SciPy ``1.15.0`` and will be removed in SciPy
``1.17.0``.
- `scipy.stats.linregress` has deprecated one-argument use; the two
variables must be specified as separate arguments.
- ``scipy.stats.trapz`` is deprecated in favor of `scipy.stats.trapezoid`.
- `scipy.special.lpn` is deprecated in favor of `scipy.special.legendre_p_all`.
- `scipy.special.lpmn` and `scipy.special.clpmn` are deprecated in favor of
`scipy.special.assoc_legendre_p_all`.
- The raveling of multi-dimensional input by `scipy.linalg.toeplitz` has
been deprecated. It will support batching in SciPy ``1.17.0``.
- The ``random_state`` and ``permutations`` arguments of
`scipy.stats.ttest_ind` are deprecated. Use ``method`` to perform a
permutation test, instead.


Expired Deprecations
================
- The wavelet functions in `scipy.signal` have been removed. This includes
``daub``, ``qmf``, ``cascade``, ``morlet``, ``morlet2``, ``ricker``,
and ``cwt``. Users should use ``pywavelets`` instead.
- ``scipy.signal.cmplx_sort`` has been removed.
- ``scipy.integrate.quadrature`` and ``scipy.integrate.romberg`` have been
removed in favour of `scipy.integrate.quad`.
- ``scipy.stats.rvs_ratio_uniforms`` has been removed in favor of
`scipy.stats.sampling.RatioUniforms`.
- `scipy.special.factorial` now raises an error for non-integer scalars when
``exact=True``.
- `scipy.integrate.cumulative_trapezoid` now raises an error for values of
``initial`` other than ``0`` and ``None``.
- Complex dtypes now raise an error in `scipy.interpolate.Akima1DInterpolator`
and `scipy.interpolate.PchipInterpolator`
- ``special.btdtr`` and ``special.btdtri`` have been removed.
- The default of the ``exact=`` kwarg in ``special.factorialk`` has changed
from ``True`` to ``False``.
- All functions in the ``scipy.misc`` submodule have been removed.


Backwards incompatible changes
==========================
- ``interpolate.BSpline.integrate`` output is now always a numpy array.
Previously, for 1D splines the output was a python float or a 0D array
depending on the value of the ``extrapolate`` argument.
- `scipy.stats.wilcoxon` now respects the ``method`` argument provided by the
user. Previously, even if ``method='exact'`` was specified, the function
would resort to ``method='approx'`` in some cases.


Other changes
============
- A separate accompanying type stubs package, ``scipy-stubs``, will be made
available with the ``1.15.0`` release. `Installation instructions are
available
<https://github.com/jorenham/scipy-stubs?tab=readme-ov-file#installation>`_.
- `scipy.stats.bootstrap` now emits a ``FutureWarning`` if the shapes of the
input arrays do not agree. Broadcast the arrays to the same batch shape
(i.e. for all dimensions except those specified by the ``axis`` argument)
to avoid the warning. Broadcasting will be performed automatically in the
future.
- SciPy endorsed `SPEC-7 <https://scientific-python.org/specs/spec-0007/>`_,
which proposes a ``rng`` argument to control pseudorandom number generation
(PRNG) in a standard way, replacing legacy arguments like ``seed`` and
``random_sate``. In many cases, use of ``rng`` will change the behavior of
the function unless the argument is already an instance of
``numpy.random.Generator``.

- Effective in SciPy ``1.15.0``:

 - The ``rng`` argument has been added to the following functions:
   `scipy.cluster.vq.kmeans`, `scipy.cluster.vq.kmeans2`,
   `scipy.interpolate.BarycentricInterpolator`,
   `scipy.interpolate.barycentric_interpolate`,
   `scipy.linalg.clarkson_woodruff_transform`,
   `scipy.optimize.basinhopping`,
   `scipy.optimize.differential_evolution`, `scipy.optimize.dual_annealing`,
   `scipy.optimize.check_grad`, `scipy.optimize.quadratic_assignment`,
   `scipy.sparse.random`, `scipy.sparse.random_array`, `scipy.sparse.rand`,
   `scipy.sparse.linalg.svds`, `scipy.spatial.transform.Rotation.random`,
   `scipy.spatial.distance.directed_hausdorff`,
   `scipy.stats.goodness_of_fit`, `scipy.stats.BootstrapMethod`,
   `scipy.stats.PermutationMethod`, `scipy.stats.bootstrap`,
   `scipy.stats.permutation_test`, `scipy.stats.dunnett`, all
   `scipy.stats.qmc` classes that consume random numbers, and
   `scipy.stats.sobol_indices`.
 - When passed by keyword, the ``rng`` argument will follow the SPEC 7
   standard behavior: the argument will be normalized with
   ``np.random.default_rng`` before being used.
 - When passed by position or legacy keyword, the behavior of the argument
   will remain unchanged (for now).

- It is planned that in ``1.17.0`` the legacy argument will start emitting
 warnings, and that in ``1.19.0`` the default behavior will change.
- In all cases, users can avoid future disruption by proactively passing
 an instance of ``np.random.Generator`` by keyword ``rng``. For details,
 see `SPEC-7 <https://scientific-python.org/specs/spec-0007/>`_.

- The SciPy build no longer adds ``-std=legacy`` for Fortran code,
except when using Gfortran. This avoids problems with the new Flang and
AMD Fortran compilers. It may make new build warnings appear for other
compilers - if so, please file an issue.


- ``scipy.signal.sosfreqz`` has been renamed to `scipy.signal.freqz_sos`.
New code should use the new name. The old name is maintained as an alias for
backwards compatibility.
- Testing thread-safety improvements related to Python ``3.13t`` have been
made in: `scipy.special`, `scipy.spatial`, `scipy.sparse`,
`scipy.interpolate`.



Authors (commits)
==============

* endolith (4)
* h-vetinari (61)
* a-drenaline (1) +
* Afleloup (1) +
* Ahmad Alkadri (1) +
* Luiz Eduardo Amaral (3) +
* Virgile Andreani (3)
* Isaac Alonso Asensio (2) +
* Matteo Bachetti (1) +
* Arash Badie-Modiri (1) +
* Arnaud Baguet (1) +
* Soutrik Bandyopadhyay (1) +
* Ankit Barik (1) +
* Christoph Baumgarten (1)
* Nickolai Belakovski (3)
* Krishan Bhasin (1) +
* Jake Bowhay (85)
* Michael Bratsch (2) +
* Matthew Brett (1)
* Keith Briggs (1) +
* Olly Britton (145) +
* Dietrich Brunn (11)
* Clemens Brunner (1)
* Evgeni Burovski (182)
* Matthias Bussonnier (7)
* CJ Carey (32)
* Cesar Carrasco (4) +
* Hood Chatham (1)
* Aadya Chinubhai (1)
* Alessandro Chitarrini (1) +
* Thibault de Coincy (1) +
* Lucas Colley (217)
* Martin Diehl (1) +
* Djip007 (1) +
* Kevin Doshi (2) +
* Michael Dunphy (2)
* Andy Everall (1) +
* Thomas J. Fan (2)
* fancidev (60)
* Sergey Fedorov (2) +
* Sahil Garje (1) +
* Gabriel Gerlero (2)
* Yotam Gingold (1) +
* Ralf Gommers (107)
* Rohit Goswami (62)
* Anil Gurses (1) +
* Oscar Gustafsson (1) +
* Matt Haberland (371)
* Matt Hall (1) +
* Joren Hammudoglu (3) +
* CY Han (1) +
* Daniel Isaac (4) +
* Maxim Ivanov (1)
* Jakob Jakobson (2)
* Janez Demšar (4) +
* Chris Jerdonek (2) +
* Adam Jones (4) +
* Aditi Juneja (1) +
* Nuri Jung (1) +
* Guus Kamphuis (1) +
* Aditya Karumanchi (2) +
* Robert Kern (5)
* Agriya Khetarpal (10)
* Andrew Knyazev (7)
* Gideon Genadi Kogan (1) +
* Damien LaRocque (1) +
* Eric Larson (10)
* Gregory R. Lee (4)
* Linfye (1) +
* Boyu Liu (1) +
* Drew Allan Loney (1) +
* Christian Lorentzen (1)
* Smit Lunagariya (1)
* Henry Lunn (1) +
* Marco Maggi (4)
* Lauren Main (1) +
* Martin Spišák (1) +
* Mateusz Sokół (4)
* Jan-Kristian Mathisen (1) +
* Nikolay Mayorov (2)
* Nicholas McKibben (1)
* Melissa Weber Mendonça (62)
* João Mendes (10)
* Gian Marco Messa (1) +
* Samuel Le Meur-Diebolt (1) +
* Michał Górny (2)
* Naoto Mizuno (2)
* Nicolas Mokus (2)
* musvaage (18) +
* Andrew Nelson (88)
* Jens Hedegaard Nielsen (1) +
* Roman Nigmatullin (8) +
* Nick ODell (37)
* Yagiz Olmez (4)
* Matti Picus (9)
* Diogo Pires (5) +
* Ilhan Polat (96)
* Zachary Potthoff (1) +
* Tom M. Ragonneau (2)
* Peter Ralph (1) +
* Stephan Rave (1) +
* Tyler Reddy (131)
* redha2404 (2) +
* Ritvik1sharma (1) +
* Érico Nogueira Rolim (1) +
* Heshy Roskes (1)
* Pamphile Roy (34)
* Mikhail Ryazanov (1) +
* Sina Saber (1) +
* Atsushi Sakai (1)
* Clemens Schmid (1) +
* Daniel Schmitz (15)
* Moritz Schreiber (1) +
* Dan Schult (88)
* Searchingdays (1) +
* Matias Senger (1) +
* Scott Shambaugh (1)
* Zhida Shang (1) +
* Sheila-nk (4)
* Romain Simon (2) +
* Gagandeep Singh (31)
* Albert Steppi (36)
* Kai Striega (1)
* Anushka Suyal (143) +
* Alex Szatmary (1)
* Svetlin Tassev (1) +
* Ewout ter Hoeven (1)
* Tibor Völcker (4) +
* Kanishk Tiwari (1) +
* Yusuke Toyama (1) +
* Edgar Andrés Margffoy Tuay (124)
* Adam Turner (2) +
* Nicole Vadot (1) +
* Andrew Valentine (1)
* Christian Veenhuis (2)
* vfdev (2) +
* Pauli Virtanen (2)
* Simon Waldherr (1) +
* Stefan van der Walt (2)
* Warren Weckesser (23)
* Anreas Weh (1)
* Benoît Wygas (2) +
* Pavadol Yamsiri (3) +
* ysard (1) +
* Xiao Yuan (2)
* Irwin Zaid (12)
* Gang Zhao (1)
* ਗਗਨਦੀਪ ਸਿੰਘ (Gagandeep Singh) (10)

A total of 148 people contributed to this release.
People with a "+" by their names contributed a patch for the first time.
This list of names is automatically generated, and may not be fully complete.

1.15.0

many new features, numerous bug-fixes, improved test coverage and better
documentation. There have been a number of deprecations and API changes
in this release, which are documented below. All users are encouraged to
upgrade to this release, as there are a large number of bug-fixes and
optimizations. Before upgrading, we recommend that users check that
their own code does not use deprecated SciPy functionality (to do so,
run your code with ``python -Wd`` and check for ``DeprecationWarning`` s).
Our development attention will now shift to bug-fix releases on the
1.15.x branch, and on adding new features on the main branch.

This release requires Python `3.10-3.13` and NumPy `1.23.5` or greater.


Highlights of this release
===================

- Sparse arrays are now fully functional for 1-D and 2-D arrays. We recommend
that all new code use sparse arrays instead of sparse matrices and that
developers start to migrate their existing code from sparse matrix to sparse
array: [ `migration_to_sparray`](https://scipy.github.io/devdocs/reference/sparse.migration_to_sparray.html). Both ``sparse.linalg`` and ``sparse.csgraph``
work with either sparse matrix or sparse array and work internally with
sparse array.
- Sparse arrays now provide basic support for n-D arrays in the COO format
including ``add``, ``subtract``, ``reshape``, ``transpose``, ``matmul``,
``dot``, ``tensordot`` and others. More functionality is coming in future
releases.
- Preliminary support for free-threaded Python 3.13.
- New probability distribution features in `scipy.stats` can be used to improve
the speed and accuracy of existing continuous distributions and perform new
probability calculations.
- `scipy.differentiate` is a new top-level submodule for accurate
estimation of derivatives of black box functions.
- `scipy.optimize.elementwise` provides vectorized root-finding and
minimization of univariate functions, and it supports the array API
as do new ``integrate`` functions ``tanhsinh``, ``nsum``, and ``cubature``.
- `scipy.interpolate.AAA` adds the AAA algorithm for barycentric rational
approximation of real or complex functions.



New features
==========

`scipy.differentiate` introduction
=========================
The new `scipy.differentiate` sub-package contains functions for accurate
estimation of derivatives of black box functions.

* Use `scipy.differentiate.derivative` for first-order derivatives of
scalar-in, scalar-out functions.
* Use `scipy.differentiate.jacobian` for first-order partial derivatives of
vector-in, vector-out functions.
* Use `scipy.differentiate.hessian` for second-order partial derivatives of
vector-in, scalar-out functions.

All functions use high-order finite difference rules with adaptive (real)
step size. To facilitate batch computation, these functions are vectorized
and support several Array API compatible array libraries in addition to NumPy
(see "Array API Standard Support" below).

`scipy.integrate` improvements
========================
- The ``QUADPACK`` Fortran77 package has been ported to C.
- `scipy.integrate.lebedev_rule` computes abscissae and weights for
integration over the surface of a sphere.
- `scipy.integrate.nsum` evaluates finite and infinite series and their
logarithms.
- `scipy.integrate.tanhsinh` is now exposed for public use, allowing
evaluation of a convergent integral using tanh-sinh quadrature.
- The new `scipy.integrate.cubature` function supports multidimensional
integration, and has support for approximating integrals with
one or more sets of infinite limits.


`scipy.interpolate` improvements
===========================
- `scipy.interpolate.AAA` adds the AAA algorithm for barycentric rational
approximation of real or complex functions.
- `scipy.interpolate.FloaterHormannInterpolator` adds barycentric rational
interpolation.
- New functions `scipy.interpolate.make_splrep` and
`scipy.interpolate.make_splprep` implement construction of smoothing splines.
The algorithmic content is equivalent to FITPACK (``splrep`` and ``splprep``
functions, and ``*UnivariateSpline`` classes) and the user API is consistent
with ``make_interp_spline``: these functions receive data arrays and return
a `scipy.interpolate.BSpline` instance.
- New generator function `scipy.interpolate.generate_knots` implements the
FITPACK strategy for selecting knots of a smoothing spline given the
smoothness parameter, ``s``. The function exposes the internal logic of knot
selection that ``splrep`` and ``*UnivariateSpline`` was using.


`scipy.linalg` improvements
======================
- `scipy.linalg.interpolative` Fortran77 code has been ported to Cython.
- `scipy.linalg.solve` supports several new values for the ``assume_a``
argument, enabling faster computation for diagonal, tri-diagonal, banded, and
triangular matrices. Also, when ``assume_a`` is left unspecified, the
function now automatically detects and exploits diagonal, tri-diagonal,
and triangular structures.
- `scipy.linalg` matrix creation functions (`scipy.linalg.circulant`,
`scipy.linalg.companion`, `scipy.linalg.convolution_matrix`,
`scipy.linalg.fiedler`, `scipy.linalg.fiedler_companion`, and
`scipy.linalg.leslie`) now support batch
matrix creation.
- `scipy.linalg.funm` is faster.
- `scipy.linalg.orthogonal_procrustes` now supports complex input.
- Wrappers for the following LAPACK routines have been added in
`scipy.linalg.lapack`: ``?lantr``, ``?sytrs``, ``?hetrs``, ``?trcon``,
and ``?gtcon``.
- `scipy.linalg.expm` was rewritten in C.
- `scipy.linalg.null_space` now accepts the new arguments ``overwrite_a``,
``check_finite``, and ``lapack_driver``.
- ``id_dist`` Fortran code was rewritten in Cython.


`scipy.ndimage` improvements
========================
- Several additional filtering functions now support an ``axes`` argument
that specifies which axes of the input filtering is to be performed on.
These include ``correlate``, ``convolve``, ``generic_laplace``, ``laplace``,
``gaussian_laplace``, ``derivative2``, ``generic_gradient_magnitude``,
``gaussian_gradient_magnitude`` and ``generic_filter``.
- The binary and grayscale morphology functions now support an ``axes``
argument that specifies which axes of the input filtering is to be performed
on.
- `scipy.ndimage.rank_filter` time complexity has improved from ``n`` to
``log(n)``.



`scipy.optimize` improvements
========================
- The vendored HiGHS library has been upgraded from ``1.4.0`` to ``1.8.0``,
bringing accuracy and performance improvements to solvers.
- The ``MINPACK`` Fortran77 package has been ported to C.
- The ``L-BFGS-B`` Fortran77 package has been ported to C.
- The new `scipy.optimize.elementwise` namespace includes functions
``bracket_root``, ``find_root``, ``bracket_minimum``, and ``find_minimum``
for root-finding and minimization of univariate functions. To facilitate
batch computation, these functions are vectorized and support several
Array API compatible array libraries in addition to NumPy (see
"Array API Standard Support" below). Compared to existing functions (e.g.
`scipy.optimize.root_scalar` and `scipy.optimize.minimize_scalar`),
these functions can offer speedups of over 100x when used with NumPy arrays,
and even greater gains are possible with other Array API Standard compatible
array libraries (e.g. CuPy).
- `scipy.optimize.differential_evolution` now supports more general use of
``workers``, such as passing a map-like callable.
- `scipy.optimize.nnls` was rewritten in Cython.
- ``HessianUpdateStrategy`` now supports ``__matmul__``.


`scipy.signal` improvements
======================
- Add functionality of complex-valued waveforms to ``signal.chirp()``.
- `scipy.signal.lombscargle` has two new arguments, ``weights`` and
``floating_mean``, enabling sample weighting and removal of an unknown
y-offset independently for each frequency. Additionally, the ``normalize``
argument includes a new option to return the complex representation of the
amplitude and phase.
- New function `scipy.signal.envelope` for computation of the envelope of a
real or complex valued signal.


`scipy.sparse` improvements
=======================
- A :ref:`migration guide<migration_to_sparray>` is now available for
moving from sparse.matrix to sparse.array in your code/library.
- Sparse arrays now support indexing for 1-D an