SciPy Changelog

What's new in SciPy 1.16.1

Apr 28, 2017

SciPy 0.16.1 is a bug-fix release with no new features compared to 0.16.0.

New in SciPy 1.15.1 (Jan 20, 2015)

New in SciPy 1.15.0 RC 1 (Jan 7, 2015)

NEW FEATURES:
Linear Programming Interface:
The new function ``scipy.optimize.linprog`` provides a generic linear programming similar to the way ``scipy.optimize.minimize`` provides a generic interface to nonlinear programming optimizers. Currently the only method supported is *simplex* which provides a two-phase, dense-matrix-based simplex algorithm. Callbacks functions are supported,allowing the user to monitor the progress of the algorithm.
Differential_evolution, a global optimizer:
A new ``differential_evolution`` function is available in the ``scipy.optimize`` module. Differential Evolution is an algorithm used for finding the global minimum of multivariate functions. It is stochastic in nature (does not use gradient methods), and can search large areas of candidate space, but often requires larger numbers of function evaluations than conventional gradient based techniques.
scipy.signal`` improvements:
The function ``max_len_seq`` was added, which computes a Maximum Length Sequence (MLS) signal.
scipy.integrate`` improvements:
It is now possible to use ``scipy.integrate`` routines to integrate multivariate ctypes functions, thus avoiding callbacks to Python and providing better performance.
scipy.linalg`` improvements:
Add function ``orthogonal_procrustes`` for solving the procrustes linear algebra problem. BLAS level 2 functions ``her``, ``syr``, ``her2`` and ``syr2`` are now wrapped in ``scipy.linalg``.
scipy.sparse`` improvements:
scipy.sparse.linalg.svds`` can now take a ``LinearOperator`` as its main input.
scipy.special`` improvements:
Values of ellipsoidal harmonic (i.e. Lame) functions and associated normalization constants can be now computed using ``ellip_harm``, ellip_harm_2``, and ``ellip_normal``.
New convenience functions ``entr``, ``rel_entr`` ``kl_div``, huber``, and ``pseudo_huber`` were added.
scipy.sparse.csgraph`` improvements:
Routines ``reverse_cuthill_mckee`` and ``maximum_bipartite_matching`` for computing reorderings of sparse graphs were added.
scipy.stats`` improvements:
Added a Dirichlet distribution as multivariate distribution.
The new function ``scipy.stats.median_test`` computes Mood's median test.
The new function ``scipy.stats.combine_pvalues`` implements Fisher's and Stouffer's methods for combining p-values.
scipy.stats.describe`` returns a namedtuple rather than a tuple, allowing users to access results by index or by name.
DEPRECATED FEATURES:
The ``scipy.weave`` module is deprecated. It was the only module never ported to Python 3.x, and is not recommended to be used for new code - use Cython instead. In order to support existing code, ``scipy.weave`` has been packaged separately: `https://github.com/scipy/weave`_. It is a pure Python package, and can easily be installed with ``pip install weave``. scipy.special.bessel_diff_formula`` is deprecated. It is a private function, and therefore will be removed from the public API in a following release. scipy.stats.nanmean``, ``nanmedian`` and ``nanstd`` functions are deprecated in favor of their numpy equivalents.
BACKWARDS INCOMPATIBLE CHANGES:
scipy.ndimage:
The functions ``scipy.ndimage.minimum_positions``, scipy.ndimage.maximum_positions`` and ``scipy.ndimage.extrema`` return positions as ints instead of floats.
scipy.integrate:
The format of banded Jacobians in ``scipy.integrate.ode`` solvers is changed. Note that the previous documentation of this feature was erroneous.

New in SciPy 1.14.1 (Jan 7, 2015)

New in SciPy 1.14.0 (May 5, 2014)

New in SciPy 1.14.0 Beta 1 (Mar 27, 2014)

New features:
``scipy.interpolate`` improvements:
A new wrapper function `scipy.interpolate.interpn` for interpolation on regular grids has been added. `interpn` supports linear and nearest-neighbor interpolation in arbitrary dimensions and spline interpolation in two dimensions.
Faster implementations of piecewise polynomials in power and Bernstein polynomial bases have been added as `scipy.interpolate.PPoly` and `scipy.interpolate.BPoly`. New users should use these in favor of `scipy.interpolate.PiecewisePolynomial`.
`scipy.interpolate.interp1d` now accepts non-monotonic inputs and sorts them. If performance is critical, sorting can be turned off by using the new ``assume_sorted`` keyword.
Functionality for evaluation of bivariate spline derivatives in ``scipy.interpolate`` has been added. The new class `scipy.interpolate.Akima1DInterpolator` implements the piecewise cubic polynomial interpolation scheme devised by H. Akima. Functionality for fast interpolation on regular, unevenly spaced grids in arbitrary dimensions has been added as `scipy.interpolate.RegularGridInterpolator` .
``scipy.linalg`` improvements:
The new function `scipy.linalg.dft` computes the matrix of the discrete Fourier transform. A condition number estimation function for matrix exponential, `scipy.linalg.expm_cond`, has been added.
``scipy.optimize`` improvements:
A set of benchmarks for optimize, which can be run with ``optimize.bench()``, has been added. `scipy.optimize.curve_fit` now has more controllable error estimation via the ``absolute_sigma`` keyword. Support for passing custom minimization methods to ``optimize.minimize()`` and ``optimize.minimize_scalar()`` has been added, currently useful especially for combining ``optimize.basinhopping()`` with custom local optimizer routines.
``scipy.stats`` improvements:
A new class `scipy.stats.multivariate_normal` with functionality for multivariate normal random variables has been added. A lot of work on the ``scipy.stats`` distribution framework has been done. Moment calculations (skew and kurtosis mainly) are fixed and verified, all examples are now runnable, and many small accuracy and performance improvements for individual distributions were merged. The new function `scipy.stats.anderson_ksamp` computes the k-sample Anderson-Darling test for the null hypothesis that k samples come from the same parent population.
``scipy.signal`` improvements:
``scipy.signal.iirfilter`` and related functions to design Butterworth, Chebyshev, elliptical and Bessel IIR filters now all use pole-zero ("zpk") format internally instead of using transformations to numerator/denominator format. The accuracy of the produced filters, especially high-order ones, is improved significantly as a result. The new function `scipy.signal.vectorstrength` computes the vector strength, a measure of phase synchrony, of a set of events.
``scipy.special`` improvements:
The functions `scipy.special.boxcox` and `scipy.special.boxcox1p`, which compute the Box-Cox transformation, have been added.
``scipy.sparse`` improvements:
Significant performance improvement in CSR, CSC, and DOK indexing speed.
When using Numpy >= 1.9 (to be released in MM 2014), sparse matrices function correctly when given to arguments of ``np.dot``, ``np.multiply`` and other ufuncs. With earlier Numpy and Scipy versions, the results of such operations are undefined and usually unexpected.
Sparse matrices are no longer limited to ``2^31`` nonzero elements. They automatically switch to using 64-bit index data type for matrices containing more elements. User code written assuming the sparse matrices use int32 as the index data type will continue to work, except for such large matrices. Code dealing with larger matrices needs to accept either int32 or int64 indices.
Deprecated features:
``anneal``:
The global minimization function `scipy.optimize.anneal` is deprecated. All users should use the `scipy.optimize.basinhopping` function instead.
``scipy.stats``:
``randwcdf`` and ``randwppf`` functions are deprecated. All users should use distribution-specific ``rvs`` methods instead. Probability calculation aliases ``zprob``, ``fprob`` and ``ksprob`` are deprecated. Use instead the ``sf`` methods of the corresponding distributions or the ``special`` functions directly.
``scipy.interpolate``:
``PiecewisePolynomial`` class is deprecated.
Backwards incompatible changes:
scipy.special.lpmn:
``lpmn`` no longer accepts complex-valued arguments. A new function ``clpmn`` with uniform complex analytic behavior has been added, and it should be used instead.
scipy.sparse.linalg:
Eigenvectors in the case of generalized eigenvalue problem are normalized to unit vectors in 2-norm, rather than following the LAPACK normalization convention. The deprecated UMFPACK wrapper in ``scipy.sparse.linalg`` has been removed due to license and install issues. If available, ``scikits.umfpack`` is still used transparently in the ``spsolve`` and ``factorized`` functions. Otherwise, SuperLU is used instead in these functions.
scipy.stats:
The deprecated functions ``glm``, ``oneway`` and ``cmedian`` have been removed from ``scipy.stats``. ``stats.scoreatpercentile`` now returns an array instead of a list of percentiles.
scipy.interpolate:
The API for computing derivatives of a monotone piecewise interpolation has changed: if `p` is a ``PchipInterpolator`` object, `p.derivative(der)` returns a callable object representing the derivative of `p`. For in-place derivatives use the second argument of the `__call__` method: `p(0.1, der=2)` evaluates the second derivative of `p` at `x=0.1`. The method `p.derivatives` has been removed.

New in SciPy 0.13.3 (Feb 17, 2014)

New in SciPy 0.13.2 (Dec 16, 2013)

New in SciPy 0.13.1 (Nov 22, 2013)

New in SciPy 0.13.0 RC 1 (Oct 16, 2013)

New features
``scipy.integrate`` improvements
--------------------------------
N-dimensional numerical integration:
A new function `scipy.integrate.nquad`, which provides N-dimensional
integration functionality with a more flexible interface than ``dblquad`` and
``tplquad``, has been added.
``dopri*`` improvements:
The intermediate results from the ``dopri`` family of ODE solvers can now be
accessed by a *solout* callback function.
``scipy.linalg`` improvements
Interpolative decompositions:
Scipy now includes a new module `scipy.linalg.interpolative`
containing routines for computing interpolative matrix decompositions
(ID). This feature is based on the ID software package by
P.G. Martinsson, V. Rokhlin, Y. Shkolnisky, and M. Tygert, previously
adapted for Python in the PymatrixId package by K.L. Ho.
Polar decomposition:
A new function `scipy.linalg.polar`, to compute the polar decomposition
of a matrix, was added.
BLAS level 3 functions:
The BLAS functions ``symm``, ``syrk``, ``syr2k``, ``hemm``, ``herk`` and
``her2k`` are now wrapped in `scipy.linalg`.
Matrix functions:
Several matrix function algorithms have been implemented or updated following
detailed descriptions in recent papers of Nick Higham and his co-authors.
These include the matrix square root (``sqrtm``), the matrix logarithm
(``logm``), the matrix exponential (``expm``) and its Frechet derivative
(``expm_frechet``), and fractional matrix powers (``fractional_matrix_power``).
``scipy.optimize`` improvements
Trust-region unconstrained minimization algorithms:
The ``minimize`` function gained two trust-region solvers for unconstrained
minimization: ``dogleg`` and ``trust-ncg``.
``scipy.sparse`` improvements
Boolean comparisons and sparse matrices:
All sparse matrix types now support boolean data, and boolean operations. Two
sparse matrices `A` and `B` can be compared in all the expected ways `A < B`,
`A >= B`, `A != B`, producing similar results as dense Numpy arrays.
Comparisons with dense matrices and scalars are also supported.
CSR and CSC fancy indexing:
Compressed sparse row and column sparse matrix types now support fancy indexing
with boolean matrices, slices, and lists. So where A is a (CSC or CSR) sparse
matrix, you can do things like::
>>> A[A > 0.5] = 1 # since Boolean sparse matrices work
>>> A[:2, :3] = 2
>>> A[[1,2], 2] = 3
``scipy.sparse.linalg`` improvements
The new function ``onenormest`` provides a lower bound of the 1-norm of a
linear operator and has been implemented according to Higham and Tisseur
(2000). This function is not only useful for sparse matrices, but can also be
used to estimate the norm of products or powers of dense matrices without
explictly building the intermediate matrix.
The multiplicative action of the matrix exponential of a linear operator
(``expm_multiply``) has been implemented following the description in Al-Mohy
and Higham (2011).
Abstract linear operators (`scipy.sparse.linalg.LinearOperator`) can now be
multiplied, added to each other, and exponentiated, producing new linear
operators. This enables easier construction of composite linear operations.
``scipy.spatial`` improvements
The vertices of a `ConvexHull` can now be accessed via the `vertices` attribute,
which gives proper orientation in 2-D.
``scipy.signal`` improvements
The cosine window function `scipy.signal.cosine` was added.
``scipy.special`` improvements
New functions `scipy.special.xlogy` and `scipy.special.xlog1py` were added.
These functions can simplify and speed up code that has to calculate
``x * log(y)`` and give 0 when ``x == 0``.
``scipy.io`` improvements
Unformatted Fortran file reader:
The new class `scipy.io.FortranFile` facilitates reading unformatted
sequential files written by Fortran code.
``scipy.io.wavfile`` enhancements:
`scipy.io.wavfile.write` now accepts a file buffer. Previously it only
accepted a filename.
`scipy.io.wavfile.read` and `scipy.io.wavfile.write` can now handle floating
point WAV files.
``scipy.interpolate`` improvements
B-spline derivatives and antiderivatives:
`scipy.interpolate.splder` and `scipy.interpolate.splantider` functions
for computing B-splines that represent derivatives and antiderivatives
of B-splines were added. These functions are also available in the
class-based FITPACK interface as ``UnivariateSpline.derivative`` and
``UnivariateSpline.antiderivative``.
``scipy.stats`` improvements
Distributions now allow using keyword parameters in addition to
positional parameters in all methods.
The function `scipy.stats.power_divergence` has been added for the
Cressie-Read power divergence statistic and goodness of fit test.
Included in this family of statistics is the "G-test"
(http://en.wikipedia.org/wiki/G-test).
`scipy.stats.mood` now accepts multidimensional input.
An option was added to `scipy.stats.wilcoxon` for continuity correction.
`scipy.stats.chisquare` now has an `axis` argument.
`scipy.stats.mstats.chisquare` now has `axis` and `ddof` arguments.
Deprecated features:
``expm2`` and ``expm3``
The matrix exponential functions `scipy.linalg.expm2` and `scipy.linalg.expm3`
are deprecated. All users should use the numerically more robust
`scipy.linalg.expm` function instead.
``scipy.stats`` functions
`scipy.stats.oneway` is deprecated; `scipy.stats.f_oneway` should be used
instead.
`scipy.stats.glm` is deprecated. `scipy.stats.ttest_ind` is an equivalent
function; more full-featured general (and generalized) linear model
implementations can be found in statsmodels.
`scipy.stats.cmedian` is deprecated; ``numpy.median`` should be used instead.
Backwards incompatible changes:
LIL matrix assignment
Assigning values to LIL matrices with two index arrays now works similarly as
assigning into ndarrays::
>>> x = lil_matrix((3, 3))
>>> x[[0,1,2],[0,1,2]]=[0,1,2]
>>> x.todense()
matrix([[ 0., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 2.]])
rather than giving the result::
>>> x.todense()
matrix([[ 0., 1., 2.],
[ 0., 1., 2.],
[ 0., 1., 2.]])
Users relying on the previous behavior will need to revisit their code.
The previous behavior is obtained by ``x[numpy.ix_([0,1,2],[0,1,2])] = ...`.
Deprecated ``radon`` function removed:
The ``misc.radon`` function, which was deprecated in scipy 0.11.0, has been
removed. Users can find a more full-featured ``radon`` function in
scikit-image.
Removed deprecated keywords ``xa`` and ``xb`` from ``stats.distributions``:
The keywords ``xa`` and ``xb``, which were deprecated since 0.11.0, have
been removed from the distributions in ``scipy.stats``.
Changes to MATLAB file readers / writers:
The major change is that 1D arrays in numpy now become row vectors (shape 1, N)
when saved to a MATLAB 5 format file. Previously 1D arrays saved as column
vectors (N, 1). This is to harmonize the behavior of writing MATLAB 4 and 5
formats, and adapt to the defaults of numpy and MATLAB - for example
``np.atleast_2d`` returns 1D arrays as row vectors.
Trying to save arrays of greater than 2 dimensions in MATLAB 4 format now raises
an error instead of silently reshaping the array as 2D.
``scipy.io.loadmat('afile')`` used to look for `afile` on the Python system path
(``sys.path``); now ``loadmat`` only looks in the current directory for a
relative path filename.
Other changes:
Security fix: ``scipy.weave`` previously used temporary directories in an
insecure manner under certain circumstances.
Cython is now required to build *unreleased* versions of scipy.
The C files generated from Cython sources are not included in the git repo
anymore. They are however still shipped in source releases.
The code base received a fairly large PEP8 cleanup. A ``tox pep8``
command has been added; new code should pass this test command.

New in SciPy 0.12.1 (Oct 16, 2013)

New in SciPy 0.12.0 (Apr 8, 2013)

New features:
``scipy.spatial`` improvements:
cKDTree feature-complete:Cython version of KDTree, cKDTree, is now feature complete. Most operations (construction, query, query_ball_point, query_pairs, count_neighbors and sparse_distance_matrix) are between 200 and 1000 times faster in cKDTree than in KDTree. With very minor caveats, cKDTree has exactly the same interface as KDTree, and can be used as a drop-in replacement.
Voronoi diagrams and convex hulls:
`scipy.spatial` now contains functionality for computing Voronoi diagrams and convex hulls using the Qhull library. (Delaunay triangulation was available since Scipy 0.9.0.)
Delaunay improvements:
It's now possible to pass in custom Qhull options in Delaunay triangulation. Coplanar points are now also recorded, if present. Incremental construction of Delaunay triangulations is now also possible.
Spectral estimators (``scipy.signal``):
The functions ``scipy.signal.periodogram`` and ``scipy.signal.welch`` were added, providing DFT-based spectral estimators.
``scipy.optimize`` improvements:
Callback functions in L-BFGS-B and TNC:
A callback mechanism was added to L-BFGS-B and TNC minimization solvers.
Basin hopping global optimization (``scipy.optimize.basinhopping``):
A new global optimization algorithm. Basinhopping is designed to efficiently find the global minimum of a smooth function.
``scipy.special`` improvements:
Revised complex error functions:
The computation of special functions related to the error function now uses a new `Faddeeva library from MIT `__ which increases their numerical precision. The scaled and imaginary error functions ``erfcx`` and ``erfi`` were also added, and the Dawson integral ``dawsn`` can now be evaluated for a complex argument.
Faster orthogonal polynomials:
Evaluation of orthogonal polynomials (the ``eval_*`` routines) in now faster in ``scipy.special``, and their ``out=`` argument functions properly.
``scipy.sparse.linalg`` features:
In ``scipy.sparse.linalg.spsolve``, the ``b`` argument can now be either a vector or a matrix. - ``scipy.sparse.linalg.inv`` was added. This uses ``spsolve`` to compute a sparse matrix inverse.
``scipy.sparse.linalg.expm`` was added. This computes the exponential of a sparse matrix using a similar algorithm to the existing dense array implementation in ``scipy.linalg.expm``.
Listing Matlab(R) file contents in ``scipy.io``:
A new function ``whosmat`` is available in ``scipy.io`` for inspecting contents of MAT files without reading them to memory.
Documented BLAS and LAPACK low-level interfaces (``scipy.linalg``):
The modules `scipy.linalg.blas` and `scipy.linalg.lapack` can be used to access low-level BLAS and LAPACK functions.
Polynomial interpolation improvements (``scipy.interpolate``):
The barycentric, Krogh, piecewise and pchip polynomial interpolators in ``scipy.interpolate`` accept now an ``axis`` argument.
Deprecated features:
`scipy.lib.lapack`:
The module `scipy.lib.lapack` is deprecated. You can use `scipy.linalg.lapack` instead. The module `scipy.lib.blas` was deprecated earlier in Scipy 0.10.0.
`fblas` and `cblas`:
Accessing the modules `scipy.linalg.fblas`, `cblas`, `flapack`, `clapack` is deprecated. Instead, use the modules `scipy.linalg.lapack` and `scipy.linalg.blas`.
Backwards incompatible changes:
Removal of ``scipy.io.save_as_module``:
The function ``scipy.io.save_as_module`` was deprecated in Scipy 0.11.0, and is now removed. Its private support modules ``scipy.io.dumbdbm_patched`` and ``scipy.io.dumb_shelve`` are also removed.

New in SciPy 0.12.0 Beta 1 (Feb 18, 2013)

New features:
``scipy.spatial`` improvements:
cKDTree feature-complete - Cython version of KDTree, cKDTree, is now feature-complete. Most operations (construction, query, query_ball_point, query_pairs, count_neighbors and sparse_distance_matrix) are between 200 and 1000 times faster in cKDTree than in KDTree. With very minor caveats, cKDTree has exactly the same interface as KDTree, and can be used as a drop-in replacement.
Voronoi diagrams and convex hulls - `scipy.spatial` now contains functionality for computing Voronoi diagrams and convex hulls using the Qhull library. (Delaunay triangulation was available since Scipy 0.9.0.)
Delaunay improvements - It's now possible to pass in custom Qhull options in Delaunay triangulation. Coplanar points are now also recorded, if present. Incremental construction of Delaunay triangulations is now also possible
Spectral estimators (``scipy.signal``) - The functions ``scipy.signal.periodogram`` and ``scipy.signal.welch`` were added, providing DFT-based spectral estimators.
``scipy.optimize`` improvements:
Callback functions in L-BFGS-B and TNC - A callback mechanism was added to L-BFGS-B and TNC minimization solvers. Basin hopping global optimization (``scipy.optimize.basinhopping``) - A new global optimization algorithm. Basinhopping is designed to efficiently find the global minimum of a smooth function.
``scipy.special`` improvements: Revised complex error functions - The computation of special functions related to the error function now uses a new `Faddeeva library __ which increases their numerical precision. The scaled and imaginary error functions ``erfcx`` and ``erfi`` were also added, and the Dawson integral ``dawsn`` can now be evaluated for a complex argument.
Faster orthogonal polynomials - Evaluation of orthogonal polynomials (the ``eval_*`` routines) in now faster in ``scipy.special``, and their ``out=`` argument functions properly.
``scipy.sparse.linalg`` features - In ``scipy.sparse.linalg.spsolve``, the ``b`` argument can now be either a vector or a matrix. - ``scipy.sparse.linalg.inv`` was added. This uses ``spsolve`` to compute a sparse matrix inverse. - ``scipy.sparse.linalg.expm`` was added. This computes the exponential of a sparse matrix using a similar algorithm to the existing dense array implementation in ``scipy.linalg.expm``.
Listing Matlab(R) file contents in ``scipy.io`` - A new function ``whosmat`` is available in ``scipy.io`` for inspecting contents of MAT files without reading them to memory.
Documented BLAS and LAPACK low-level interfaces (``scipy.linalg``) - The modules `scipy.linalg.blas` and `scipy.linalg.lapack` can be used to access low-level BLAS and LAPACK functions.
Polynomial interpolation improvements (``scipy.interpolate``) - The barycentric, Krogh, piecewise and pchip polynomial interpolators in ``scipy.interpolate`` accept now an ``axis`` argument.
Deprecated features:
`scipy.lib.lapack`:
The module `scipy.lib.lapack` is deprecated. You can use `scipy.linalg.lapack` instead. The module `scipy.lib.blas` was deprecated earlier in Scipy 0.10.0.
`fblas` and `cblas`:
Accessing the modules `scipy.linalg.fblas`, `cblas`, `flapack`, `clapack` is deprecated. Instead, use the modules `scipy.linalg.lapack` and `scipy.linalg.blas`.
Backwards incompatible changes:
Removal of ``scipy.io.save_as_module``:
The function ``scipy.io.save_as_module`` was deprecated in Scipy 0.11.0, and is now removed. Its private support modules ``scipy.io.dumbdbm_patched`` and ``scipy.io.dumb_shelve`` are also removed.

New in SciPy 0.11.0 (Sep 26, 2012)

Sparse Graph Submodule :
The new submodule :mod:`scipy.sparse.csgraph` implements a number of efficient graph algorithms for graphs stored as sparse adjacency matrices. Available routines are:
:func:`connected_components` - determine connected components of a graph
:func:`laplacian` - compute the laplacian of a graph
:func:`shortest_path` - compute the shortest path between points on a positive graph
:func:`dijkstra` - use Dijkstra's algorithm for shortest path
:func:`floyd_warshall` - use the Floyd-Warshall algorithm for shortest path
:func:`breadth_first_order` - compute a breadth-first order of nodes
:func:`depth_first_order` - compute a depth-first order of nodes
:func:`breadth_first_tree` - construct the breadth-first tree from a given node
:func:`depth_first_tree` - construct a depth-first tree from a given node
:func:`minimum_spanning_tree` - construct the minimum spanning tree of a graph
``scipy.optimize`` improvements:
The optimize module has received a lot of attention this release. In addition to added tests, documentation improvements, bug fixes and code clean-up, the following improvements were made:
A unified interface to minimizers of univariate and multivariate functions has been added.
A unified interface to root finding algorithms for multivariate functions has been added.
The L-BFGS-B algorithm has been updated to version 3.0.
Unified interfaces to minimizers:
Two new functions ``scipy.optimize.minimize`` and ``scipy.optimize.minimize_scalar`` were added to provide a common interface to minimizers of multivariate and univariate functions respectively. For multivariate functions, ``scipy.optimize.minimize`` provides an interface to methods for unconstrained optimization (`fmin`, `fmin_powell`, `fmin_cg`, `fmin_ncg`, `fmin_bfgs` and `anneal`) or constrained optimization (`fmin_l_bfgs_b`, `fmin_tnc`, `fmin_cobyla` and `fmin_slsqp`). For univariate functions, ``scipy.optimize.minimize_scalar`` provides an interface to methods for unconstrained and bounded optimization (`brent`, `golden`, `fminbound`). This allows for easier comparing and switching between solvers.
Unified interface to root finding algorithms:
The new function ``scipy.optimize.root`` provides a common interface to root finding algorithms for multivariate functions, embeding `fsolve`, `leastsq` and `nonlin` solvers.
``scipy.linalg`` improvements:
New matrix equation solvers
Solvers for the Sylvester equation (``scipy.linalg.solve_sylvester``, discrete and continuous Lyapunov equations (``scipy.linalg.solve_lyapunov``, ``scipy.linalg.solve_discrete_lyapunov``) and discrete and continuous algebraic Riccati equations (``scipy.linalg.solve_continuous_are``, ``scipy.linalg.solve_discrete_are``) have been added to ``scipy.linalg``. These solvers are often used in the field of linear control theory.
QZ and QR Decomposition:
It is now possible to calculate the QZ, or Generalized Schur, decomposition using ``scipy.linalg.qz``. This function wraps the LAPACK routines sgges, dgges, cgges, and zgges.
The function ``scipy.linalg.qr_multiply``, which allows efficient computation of the matrix product of Q (from a QR decompostion) and a vector, has been added.
Pascal matrices:
A function for creating Pascal matrices, ``scipy.linalg.pascal``, was added.
Sparse matrix construction and operations:
Two new functions, ``scipy.sparse.diags`` and ``scipy.sparse.block_diag``, were added to easily construct diagonal and block-diagonal sparse matrices respectively.
``scipy.sparse.csc_matrix`` and ``csr_matrix`` now support the operations ``sin``, ``tan``, ``arcsin``, ``arctan``, ``sinh``, ``tanh``, ``arcsinh``, ``arctanh``, ``rint``, ``sign``, ``expm1``, ``log1p``, ``deg2rad``, ``rad2deg``, ``floor``, ``ceil`` and ``trunc``. Previously, these operations had to be performed by operating on the matrices' ``data`` attribute.
LSMR iterative solver:
LSMR, an iterative method for solving (sparse) linear and linear least-squares systems, was added as ``scipy.sparse.linalg.lsmr``.
Discrete Sine Transform:
Bindings for the discrete sine transform functions have been added to ``scipy.fftpack``.
``scipy.interpolate`` improvements:
For interpolation in spherical coordinates, the three classes ``scipy.interpolate.SmoothSphereBivariateSpline``, ``scipy.interpolate.LSQSphereBivariateSpline``, and ``scipy.interpolate.RectSphereBivariateSpline`` have been added.
Binned statistics (``scipy.stats``):
The stats module has gained functions to do binned statistics, which are a generalization of histograms, in 1-D, 2-D and multiple dimensions: ``scipy.stats.binned_statistic``, ``scipy.stats.binned_statistic_2d`` and ``scipy.stats.binned_statistic_dd``.
Deprecated features:
``scipy.sparse.cs_graph_components`` has been made a part of the sparse graph submodule, and renamed to ``scipy.sparse.csgraph.connected_components``. Calling the former routine will result in a deprecation warning. ``scipy.misc.radon`` has been deprecated. A more full-featured radon transform can be found in scikits-image. ``scipy.io.save_as_module`` has been deprecated. A better way to save multiple Numpy arrays is the ``numpy.savez`` function. The `xa` and `xb` parameters for all distributions in ``scipy.stats.distributions`` already weren't used; they have now been deprecated.
Backwards incompatible changes:
Removal of ``scipy.maxentropy``
The ``scipy.maxentropy`` module, which was deprecated in the 0.10.0 release, has been removed. Logistic regression in scikits.learn is a good and modern alternative for this functionality.
Minor change in behavior of ``splev``:
The spline evaluation function now behaves similarly to ``interp1d`` for size-1 arrays.
Previous behavior:
>>> from scipy.interpolate import splev, splrep, interp1d
>>> x = [1,2,3,4,5]
>>> y = [4,5,6,7,8]
>>> tck = splrep(x, y)
>>> splev([1], tck) 4.
>>> splev(1, tck) 4.
Corrected behavior:
>>> splev([1], tck) array([ 4.])
>>> splev(1, tck) array(4.) This affects also the ``UnivariateSpline`` classes.
Behavior of ``scipy.integrate.complex_ode``:
The behavior of the ``y`` attribute of ``complex_ode`` is changed. Previously, it expressed the complex-valued solution in the form:: z = ode.y[::2] + 1j * ode.y[1::2] Now, it is directly the complex-valued solution:: z = ode.y
Minor change in behavior of T-tests:
The T-tests ``scipy.stats.ttest_ind``, ``scipy.stats.ttest_rel`` and ``scipy.stats.ttest_1samp`` have been changed so that 0 / 0 now returns NaN instead of 1.
Other changes:
The SuperLU sources in ``scipy.sparse.linalg`` have been updated to version 4.3 from upstream.
The function ``scipy.signal.bode``, which calculates magnitude and phase data for a continuous-time system, has been added.
The two-sample T-test ``scipy.stats.ttest_ind`` gained an option to compare samples with unequal variances, i.e. Welch's T-test. ``scipy.misc.logsumexp`` now takes an optional ``axis`` keyword argument.

New in SciPy 0.11.0 RC 2 (Aug 14, 2012)

New features:
Sparse Graph Submodule:
The new submodule :mod:`scipy.sparse.csgraph` implements a number of efficient graph algorithms for graphs stored as sparse adjacency matrices. Available routines are:
:func:`connected_components` - determine connected components of a graph
:func:`laplacian` - compute the laplacian of a graph
:func:`shortest_path` - compute the shortest path between points on a positive graph - :func:`dijkstra` - use Dijkstra's algorithm for shortest path :func:`floyd_warshall` - use the Floyd-Warshall algorithm for shortest path :func:`breadth_first_order` - compute a breadth-first order of nodes :func:`depth_first_order` - compute a depth-first order of nodes :func:`breadth_first_tree` - construct the breadth-first tree from a given node
:func:`depth_first_tree` - construct a depth-first tree from a given node :func:`minimum_spanning_tree` - construct the minimum spanning tree of a graph
``scipy.optimize`` improvements
The optimize module has received a lot of attention this release. In addition to added tests, documentation improvements, bug fixes and code clean-up, the following improvements were made:
A unified interface to minimizers of univariate and multivariate functions has been added.
A unified interface to root finding algorithms for multivariate functions has been added.
The L-BFGS-B algorithm has been updated to version 3.0. Unified interfaces to minimizers
Two new functions ``scipy.optimize.minimize`` and ``scipy.optimize.minimize_scalar`` were added to provide a common interface to minimizers of multivariate and univariate functions respectively. For multivariate functions, ``scipy.optimize.minimize`` provides an interface to methods for unconstrained optimization (`fmin`, `fmin_powell`, `fmin_cg`, `fmin_ncg`, `fmin_bfgs` and `anneal`) or constrained optimization (`fmin_l_bfgs_b`, `fmin_tnc`, `fmin_cobyla` and `fmin_slsqp`). For univariate functions, ``scipy.optimize.minimize_scalar`` provides an interface to methods for unconstrained and bounded optimization (`brent`, `golden`, `fminbound`). This allows for easier comparing and switching between solvers. Unified interface to root finding algorithms
The new function ``scipy.optimize.root`` provides a common interface to root finding algorithms for multivariate functions, embedding `fsolve`, `leastsq` and `nonlin` solvers.
``scipy.linalg`` improvements
New matrix equation solvers
Solvers for the Sylvester equation (``scipy.linalg.solve_sylvester``, discrete and continuous Lyapunov equations (``scipy.linalg.solve_lyapunov``, ``scipy.linalg.solve_discrete_lyapunov``) and discrete and continuous algebraic Riccati equations (``scipy.linalg.solve_continuous_are``, ``scipy.linalg.solve_discrete_are``) have been added to ``scipy.linalg``. These solvers are often used in the field of linear control theory. QZ and QR Decomposition
It is now possible to calculate the QZ, or Generalized Schur, decomposition using ``scipy.linalg.qz``. This function wraps the LAPACK routines sgges, dgges, cgges, and zgges. The function ``scipy.linalg.qr_multiply``, which allows efficient computation of the matrix product of Q (from a QR decompostion) and a vector, has been added. Pascal matrices
A function for creating Pascal matrices,
``scipy.linalg.pascal``, was added. Sparse matrix construction and operations
Two new functions, ``scipy.sparse.diags`` and ``scipy.sparse.block_diag``, were added to easily construct diagonal and block-diagonal sparse matrices respectively. ``scipy.sparse.csc_matrix`` and ``csr_matrix`` now support the operations ``sin``, ``tan``, ``arcsin``, ``arctan``, ``sinh``, ``tanh``, ``arcsinh``, ``arctanh``, ``rint``, ``sign``, ``expm1``, ``log1p``, ``deg2rad``, ``rad2deg``, ``floor``, ``ceil`` and ``trunc``. Previously, these operations had to be performed by operating on the matrices' ``data`` attribute.
LSMR iterative solver
LSMR, an iterative method for solving (sparse) linear and linear least-squares systems, was added as ``scipy.sparse.linalg.lsmr``.
Discrete Sine Transform
Bindings for the discrete sine transform functions have been added to ``scipy.fftpack``.
``scipy.interpolate`` improvements
For interpolation in spherical coordinates, the three classes ``scipy.interpolate.SmoothSphereBivariateSpline``, ``scipy.interpolate.LSQSphereBivariateSpline``, and ``scipy.interpolate.RectSphereBivariateSpline`` have been added.
Binned statistics (``scipy.stats``)
The stats module has gained functions to do binned statistics, which are a generalization of histograms, in 1-D, 2-D and multiple dimensions: ``scipy.stats.binned_statistic``, ``scipy.stats.binned_statistic_2d`` and ``scipy.stats.binned_statistic_dd``.
Deprecated features
``scipy.sparse.cs_graph_components`` has been made a part of the sparse graph submodule, and renamed to ``scipy.sparse.csgraph.connected_components``. Calling the former routine will result in a deprecation warning. ``scipy.misc.radon`` has been deprecated. A more full-featured radon transform can be found in scikits-image. ``scipy.io.save_as_module`` has been deprecated. A better way to save multiple Numpy arrays is the ``numpy.savez`` function. The `xa` and `xb` parameters for all distributions in ``scipy.stats.distributions`` already weren't used; they have now been deprecated.
Backwards incompatible change
Removal of ``scipy.maxentropy``
The ``scipy.maxentropy`` module, which was deprecated in the 0.10.0 release, has been removed. Logistic regression in scikits.learn is a good and modern alternative for this functionality. Minor change in behavior of ``splev``
The spline evaluation function now behaves similarly to ``interp1d`` for size-1 arrays. Previous behavior:: >>> from scipy.interpolate import splev, splrep, interp1d >>> x = [1,2,3,4,5] >>> y = [4,5,6,7,8] >>> tck = splrep(x, y) >>> splev([1], tck) 4. >>> splev(1, tck) 4. Corrected behavior:: >>> splev([1], tck) array([ 4.]) >>> splev(1, tck) array(4.) This affects also the ``UnivariateSpline`` classes.
Behavior of ``scipy.integrate.complex_ode``
The behavior of the ``y`` attribute of ``complex_ode`` is changed. Previously, it expressed the complex-valued solution in the form:: z = ode.y[::2] + 1j * ode.y[1::2] Now, it is directly the complex-valued solution:: z = ode.y Minor change in behavior of
T-tests
he T-tests ``scipy.stats.ttest_ind``, ``scipy.stats.ttest_rel`` and ``scipy.stats.ttest_1samp`` have been changed so that 0 / 0 now returns NaN instead of 1.
Other changes
The SuperLU sources in ``scipy.sparse.linalg`` have been updated to version 4.3 from upstream. The function ``scipy.signal.bode``, which calculates magnitude and phase data for a continuous-time system, has been added. The two-sample T-test ``scipy.stats.ttest_ind`` gained an option to compare samples with unequal variances, i.e. Welch's T-test. ``scipy.misc.logsumexp`` now takes an optional ``axis`` keyword argument.

New in SciPy 0.11.0 Beta 1 (Jun 14, 2012)

Sparse Graph Submodule
The new submodule :mod:`scipy.sparse.csgraph` implements a number of efficient graph algorithms for graphs stored as sparse adjacency matrices. Available routines are:
:func:`connected_components` determine connected components of a graph - :func:`laplacian` compute the laplacian of a graph
:func:`shortest_path` compute the shortest path between points on a positive graph
:func:`dijkstra` use Dijkstra's algorithm for shortest path :func:`floyd_warshall` use the Floyd-Warshall algorithm for shortest path :func:`breadth_first_order` compute a breadth-first order of nodes :func:`depth_first_order` compute a depth-first order of nodes :func:`breadth_first_tree` construct the breadth-first tree from a given node :func:`depth_first_tree` construct a depth-first tree from a given node :func:`minimum_spanning_tree` construct the minimum spanning tree of a graph
``scipy.optimize`` improvements
The optimize module has received a lot of attention this release. In addition to added tests, documentation improvements, bug fixes and code clean-up, the following improvements were made:
A unified interface to minimizers of univariate and multivariate functions has been added.
A unified interface to root finding algorithms for multivariate functions has been added.
The L-BFGS-B algorithm has been updated to version 3.0.
Unified interfaces to minimizers
Two new functions ``scipy.optimize.minimize`` and ``scipy.optimize.minimize_scalar`` were added to provide a common interface to minimizers of multivariate and univariate functions respectively. For multivariate functions,
``scipy.optimize.minimize`` provides an interface to methods for unconstrained optimization (`fmin`, `fmin_powell`, `fmin_cg`, `fmin_ncg`, `fmin_bfgs` and `anneal`) or constrained optimization (`fmin_l_bfgs_b`, `fmin_tnc`, `fmin_cobyla` and `fmin_slsqp`).
For univariate functions, ``scipy.optimize.minimize_scalar`` provides an interface to methods for unconstrained and bounded optimization (`brent`, `golden`, `fminbound`). This allows for easier comparing and switching between solvers. Unified interface to root finding algorithms The new function ``scipy.optimize.root`` provides a common interface to root finding algorithms for multivariate functions, embeding `fsolve`, `leastsq` and `nonlin` solvers.
``scipy.linalg`` improvements
New matrix equation solvers
Solvers for the Sylvester equation (``scipy.linalg.solve_sylvester``, discrete and continuous Lyapunov equations (``scipy.linalg.solve_lyapunov``, ``scipy.linalg.solve_discrete_lyapunov``) and discrete and continuous algebraic Riccati equations (``scipy.linalg.solve_continuous_are``, ``scipy.linalg.solve_discrete_are``) have been added to ``scipy.linalg``. These solvers are often used in the field of linear control theory. QZ and QR
Decomposition
It is now possible to calculate the QZ, or Generalized Schur, decomposition using ``scipy.linalg.qz``. This function wraps the LAPACK routines sgges, dgges, cgges, and zgges. The function ``scipy.linalg.qr_multiply``, which allows efficient computation of the matrix product of Q (from a QR decompostion) and a vector, has been added.
Pascal matrices
A function for creating Pascal matrices, ``scipy.linalg.pascal``, was added. Sparse matrix construction and operations
Two new functions, ``scipy.sparse.diags`` and ``scipy.sparse.block_diag``, were added to easily construct diagonal and block-diagonal sparse matrices respectively. ``scipy.sparse.csc_matrix`` and ``csr_matrix`` now support the operations ``sin``, ``tan``, ``arcsin``, ``arctan``, ``sinh``, ``tanh``, ``arcsinh``, ``arctanh``, ``rint``, ``sign``, ``expm1``, ``log1p``, ``deg2rad``, ``rad2deg``, ``floor``, ``ceil`` and ``trunc``. Previously, these operations had to be performed by operating on the matrices' ``data`` attribute.
LSMR iterative solver
LSMR, an iterative method for solving (sparse) linear and linear least-squares systems, was added as ``scipy.sparse.linalg.lsmr``.
Discrete Sine Transform
Bindings for the discrete sine transform functions have been added to ``scipy.fftpack``. ``scipy.interpolate`` improvements
For interpolation in spherical coordinates, the three classes ``scipy.interpolate.SmoothSphereBivariateSpline``, ``scipy.interpolate.LSQSphereBivariateSpline``, and ``scipy.interpolate.RectSphereBivariateSpline`` have been added. Binned statistics (``scipy.stats``)
The stats module has gained functions to do binned statistics, which are a generalization of histograms, in 1-D, 2-D and multiple dimensions: ``scipy.stats.binned_statistic``, ``scipy.stats.binned_statistic_2d`` and ``scipy.stats.binned_statistic_dd``.
Deprecated features ``scipy.sparse.cs_graph_components`` has been made a part of the sparse graph submodule, and renamed to ``scipy.sparse.csgraph.connected_components``. Calling the former routine will result in a deprecation warning. ``scipy.misc.radon`` has been deprecated. A more full-featured radon transform can be found in scikits-image. ``scipy.io.save_as_module`` has been deprecated. A better way to save multiple Numpy arrays is the ``numpy.savez`` function. The `xa` and `xb` parameters for all distributions in ``scipy.stats.distributions`` already weren't used; they have now been deprecated.
Backwards incompatible changes
Removal of ``scipy.maxentropy``
The ``scipy.maxentropy`` module, which was deprecated in the 0.10.0 release, has been removed. Logistic regression in scikits.learn is a good and modern alternative for this functionality. alternative for this functionality. Minor change in behavior of ``splev``
The spline evaluation function now behaves similarly to ``interp1d`` for size-1 arrays. Previous behavior:: >>> from scipy.interpolate import splev, splrep, interp1d >>> x = [1,2,3,4,5] >>> y = [4,5,6,7,8] >>> tck = splrep(x, y) >>> splev([1], tck) 4. >>> splev(1, tck) 4. Corrected behavior:: >>> splev([1], tck) array([ 4.]) >>> splev(1, tck) array(4.) This affects also the ``UnivariateSpline`` classes. Behavior of ``scipy.integrate.complex_ode`
The behavior of the ``y`` attribute of ``complex_ode`` is changed. Previously, it expressed the complex-valued solution in the form:: z = ode.y[::2] + 1j * ode.y[1::2] Now, it is directly the complex-valued solution:: z = ode.y Minor change in behavior of T-tests
The T-tests ``scipy.stats.ttest_ind``, ``scipy.stats.ttest_rel`` and ``scipy.stats.ttest_1samp`` have been changed so that 0 / 0 now returns NaN instead of 1.
Other changes
The SuperLU sources in ``scipy.sparse.linalg`` have been updated to version 4.3 from upstream. The function ``scipy.signal.bode``, which calculates magnitude and phase data for a continuous-time system, has been added. The two-sample T-test ``scipy.stats.ttest_ind`` gained an option to compare samples with unequal variances, i.e. Welch's T-test. ``scipy.misc.logsumexp`` now takes an optional ``axis`` keyword argument.