Log message:
Updated pyscipy to 0.18.0.
Test failures reported upstream.
==========================
SciPy 0.18.0 Release Notes
==========================
.. contents::
SciPy 0.18.0 is the culmination of 6 months of hard work. It contains
many new features, numerous bugfixes, 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 bugfixes and optimizations. Moreover, our development attention
will now shift to bugfix releases on the 0.19.x branch, and on adding
new features on the master branch.
This release requires Python 2.7 or 3.43.5 and NumPy 1.7.1 or greater.
Highlights of this release include:
 A new ODE solver for twopoint boundary value problems,
`scipy.optimize.solve_bvp`.
 A new class, `CubicSpline`, for cubic spline interpolation of data.
 Ndimensional tensor product polynomials, `scipy.interpolate.NdPPoly`.
 Spherical Voronoi diagrams, `scipy.spatial.SphericalVoronoi`.
 Support for discretetime linear systems, `scipy.signal.dlti`.
New features
============
`scipy.integrate` improvements

A solver of twopoint boundary value problems for ODE systems has been
implemented in `scipy.integrate.solve_bvp`. The solver allows for nonseparated
boundary conditions, unknown parameters and certain singular terms. It finds
a C1 continious solution using a fourthorder collocation algorithm.
`scipy.interpolate` improvements

Cubic spline interpolation is now available via `scipy.interpolate.CubicSpline`.
This class represents a piecewise cubic polynomial passing through given points
and C2 continuous. It is represented in the standard polynomial basis on each
segment.
A representation of ndimensional tensor product piecewise polynomials is
available as the `scipy.interpolate.NdPPoly` class.
Univariate piecewise polynomial classes, `PPoly` and `Bpoly`, can now be
evaluated on periodic domains. Use ``extrapolate="periodic"`` keyword
argument for this.
`scipy.fftpack` improvements

`scipy.fftpack.next_fast_len` function computes the next "regular" \
number for
FFTPACK. Padding the input to this length can give significant performance
increase for `scipy.fftpack.fft`.
`scipy.signal` improvements

Resampling using polyphase filtering has been implemented in the function
`scipy.signal.resample_poly`. This method upsamples a signal, applies a
zerophase lowpass FIR filter, and downsamples using `scipy.signal.upfirdn`
(which is also new in 0.18.0). This method can be faster than FFTbased
filtering provided by `scipy.signal.resample` for some signals.
`scipy.signal.firls`, which constructs FIR filters using leastsquares error
minimization, was added.
`scipy.signal.sosfiltfilt`, which does forwardbackward filtering like
`scipy.signal.filtfilt` but for secondorder sections, was added.
Discretetime linear systems
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
`scipy.signal.dlti` provides an implementation of discretetime linear systems.
Accordingly, the `StateSpace`, `TransferFunction` and `ZerosPolesGain` classes
have learned a the new keyword, `dt`, which can be used to create discretetime
instances of the corresponding system representation.
`scipy.sparse` improvements

The functions `sum`, `max`, `mean`, `min`, `transpose`, and `reshape` in
`scipy.sparse` have had their signatures augmented with additional arguments
and functionality so as to improve compatibility with analogously defined
functions in `numpy`.
Sparse matrices now have a `count_nonzero` method, which counts the number of
nonzero elements in the matrix. Unlike `getnnz()` and ``nnz`` propety,
which return the number of stored entries (the length of the data attribute),
this method counts the actual number of nonzero entries in data.
`scipy.optimize` improvements

The implementation of NelderMead minimization,
`scipy.minimize(..., method="NelderMead")`, obtained a new keyword,
`initial_simplex`, which can be used to specify the initial simplex for the
optimization process.
Initial step size selection in CG and BFGS minimizers has been improved. We
expect that this change will improve numeric stability of optimization in some
cases. See pull request gh5536 for details.
Handling of infinite bounds in SLSQP optimization has been improved. We expect
that this change will improve numeric stability of optimization in the some
cases. See pull request gh6024 for details.
A large suite of global optimization benchmarks has been added to
``scipy/benchmarks/go_benchmark_functions``. See pull request gh4191 for details.
NelderMead and Powell minimization will now only set defaults for
maximum iterations or function evaluations if neither limit is set by
the caller. In some cases with a slow converging function and only 1
limit set, the minimization may continue for longer than with previous
versions and so is more likely to reach convergence. See issue gh5966.
`scipy.stats` improvements

Trapezoidal distribution has been implemented as `scipy.stats.trapz`.
Skew normal distribution has been implemented as `scipy.stats.skewnorm`.
Burr type XII distribution has been implemented as `scipy.stats.burr12`.
Three and fourparameter kappa distributions have been implemented as
`scipy.stats.kappa3` and `scipy.stats.kappa4`, respectively.
New `scipy.stats.iqr` function computes the interquartile region of a
distribution.
Random matrices
~~~~~~~~~~~~~~~
`scipy.stats.special_ortho_group` and `scipy.stats.ortho_group` provide
generators of random matrices in the SO(N) and O(N) groups, respectively. They
generate matrices in the Haar distribution, the only uniform distribution on
these group manifolds.
`scipy.stats.random_correlation` provides a generator for random
correlation matrices, given specified eigenvalues.
`scipy.linalg` improvements

`scipy.linalg.svd` gained a new keyword argument, ``lapack_driver``. Available
drivers are ``gesdd`` (default) and ``gesvd``.
`scipy.linalg.lapack.ilaver` returns the version of the LAPACK library SciPy
links to.
`scipy.spatial` improvements

Boolean distances, `scipy.spatial.pdist`, have been sped up. Improvements vary
by the function and the input size. In many cases, one can expect a speedup
of x2x10.
New class `scipy.spatial.SphericalVoronoi` constructs Voronoi diagrams on the
surface of a sphere. See pull request gh5232 for details.
`scipy.cluster` improvements

A new clustering algorithm, the nearest neighbor chain algorithm, has been
implemented for `scipy.cluster.hierarchy.linkage`. As a result, one can expect
a significant algorithmic improvement (:math:`O(N^2)` instead of :math:`O(N^3)`)
for several linkage methods.
`scipy.special` improvements

The new function `scipy.special.loggamma` computes the principal branch of the
logarithm of the Gamma function. For real input, ``loggamma`` is compatible
with `scipy.special.gammaln`. For complex input, it has more consistent
behavior in the complex plane and should be preferred over ``gammaln``.
Vectorized forms of spherical Bessel functions have been implemented as
`scipy.special.spherical_jn`, `scipy.special.spherical_kn`,
`scipy.special.spherical_in` and `scipy.special.spherical_yn`.
They are recommended for use over ``sph_*`` functions, which are now deprecated.
Several special functions have been extended to the complex domain and/or
have seen domain/stability improvements. This includes `spence`, `digamma`,
`log1p` and several others.
Deprecated features
===================
The crossclass properties of `lti` systems have been deprecated. The
following properties/setters will raise a `DeprecationWarning`:
Name  (accessing/setting raises warning)  (setting raises warning)
* StateSpace  (`num`, `den`, `gain`)  (`zeros`, `poles`)
* TransferFunction (`A`, `B`, `C`, `D`, `gain`)  (`zeros`, `poles`)
* ZerosPolesGain (`A`, `B`, `C`, `D`, `num`, `den`)  ()
Spherical Bessel functions, ``sph_in``, ``sph_jn``, ``sph_kn``, ``sph_yn``,
``sph_jnyn`` and ``sph_inkn`` have been deprecated in favor of
`scipy.special.spherical_jn` and ``spherical_kn``, ``spherical_yn``,
``spherical_in``.
The following functions in `scipy.constants` are deprecated: ``C2K``, ``K2C``,
``C2F``, ``F2C``, ``F2K`` and ``K2F``. They are superceded by a new function
`scipy.constants.convert_temperature` that can perform all those conversions
plus to/from the Rankine temperature scale.
Backwards incompatible changes
==============================
`scipy.optimize`

The convergence criterion for ``optimize.bisect``,
``optimize.brentq``, ``optimize.brenth``, and ``optimize.ridder`` now
works the same as ``numpy.allclose``.
`scipy.ndimage`

The offset in ``ndimage.iterpolation.affine_transform``
is now consistently added after the matrix is applied,
independent of if the matrix is specified using a onedimensional
or a twodimensional array.
`scipy.stats`

``stats.ks_2samp`` used to return nonsensical values if the input was
not real or contained nans. It now raises an exception for such inputs.
Several deprecated methods of `scipy.stats` distributions have been removed:
``est_loc_scale``, ``vecfunc``, ``veccdf`` and ``vec_generic_moment``.
Deprecated functions ``nanmean``, ``nanstd`` and ``nanmedian`` have been removed
from `scipy.stats`. These functions were deprecated in scipy 0.15.0 in favor
of their `numpy` equivalents.
A bug in the ``rvs()`` method of the distributions in `scipy.stats` has
been fixed. When arguments to ``rvs()`` were given that were shaped for
broadcasting, in many cases the returned random samples were not random.
A simple example of the problem is ``stats.norm.rvs(loc=np.zeros(10))``.
Because of the bug, that call would return 10 identical values. The bug
only affected code that relied on the broadcasting of the shape, location
and scale parameters.
The ``rvs()`` method also accepted some arguments that it should not have.
There is a potential for backwards incompatibility in cases where ``rvs()``
accepted arguments that are not, in fact, compatible with broadcasting.
An example is
stats.gamma.rvs([2, 5, 10, 15], size=(2,2))
The shape of the first argument is not compatible with the requested size,
but the function still returned an array with shape (2, 2). In scipy 0.18,
that call generates a ``ValueError``.
`scipy.io`

`scipy.io.netcdf` masking now gives precedence to the ``_FillValue`` attribute
over the ``missing_value`` attribute, if both are given. Also, data are only
treated as missing if they match one of these attributes exactly: values that
differ by roundoff from ``_FillValue`` or ``missing_value`` are no longer
treated as missing values.
`scipy.interpolate`

`scipy.interpolate.PiecewisePolynomial` class has been removed. It has been
deprecated in scipy 0.14.0, and `scipy.interpolate.BPoly.from_derivatives` serves
as a dropin replacement.
Other changes
=============
Scipy now uses ``setuptools`` for its builds instead of plain distutils. This
fixes usage of ``install_requires='scipy'`` in the ``setup.py`` files of
projects that depend on Scipy (see Numpy issue gh6551 for details). It
potentially affects the way that build/install methods for Scipy itself behave
though. Please report any unexpected behavior on the Scipy issue tracker.
PR `#6240 <https://github.com/scipy/scipy/pull/6240>`__
changes the interpretation of the `maxfun` option in `LBFGSB` based routines
in the `scipy.optimize` module.
An `LBFGSB` search consists of multiple iterations,
with each iteration consisting of one or more function evaluations.
Whereas the old search strategy terminated immediately upon reaching `maxfun`
function evaluations, the new strategy allows the current iteration
to finish despite reaching `maxfun`.
The bundled copy of Qhull in the `scipy.spatial` subpackage has been upgraded to
version 2015.2.
The bundled copy of ARPACK in the `scipy.sparse.linalg` subpackage has been
upgraded to arpackng 3.3.0.
The bundled copy of SuperLU in the `scipy.sparse` subpackage has been upgraded
to version 5.1.1.

Log message:
Update to 0.15.1
Upstream changes:
SciPy 0.15.1 is a bugfix release with no new features compared to 0.15.0.
Issues fixed
 
* `#4413 <https://github.com/scipy/scipy/pull/4413>`__: BUG: Tests too \
strict, f2py doesn't have to overwrite this array
* `#4417 <https://github.com/scipy/scipy/pull/4417>`__: BLD: avoid using \
NPY_API_VERSION to check not using deprecated...
* `#4418 <https://github.com/scipy/scipy/pull/4418>`__: Restore and \
deprecate scipy.linalg.calc_work
SciPy 0.15.0 Release Notes
==========================
.. contents::
SciPy 0.15.0 is the culmination of 6 months of hard work. It contains
several new features, numerous bugfixes, 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 bugfixes and optimizations. Moreover, our development attention
will now shift to bugfix releases on the 0.16.x branch, and on adding
new features on the master branch.
This release requires Python 2.6, 2.7 or 3.23.4 and NumPy 1.5.1 or greater.
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 twophase, densematrixbased simplex algorithm. Callbacks
functions are supported, allowing the user to monitor the progress
of the algorithm.
Differential evolution, a global optimizer
 
A new `scipy.optimize.differential_evolution` function has been added to the
``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 `scipy.signal.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
 
The function `scipy.linalg.orthogonal_procrustes` for solving the procrustes
linear algebra problem was added.
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 multivariate distribution, `scipy.stats.dirichlet`.
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 pvalues.
`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.
SciPy 0.14.1 Release Notes
==========================
SciPy 0.14.1 is a bugfix release with no new features compared to 0.14.0.
Issues closed
 
  `#3630 <https://github.com/scipy/scipy/issues/3630>`__: NetCDF reading \
results in a segfault
  `#3631 <https://github.com/scipy/scipy/issues/3631>`__: SuperLU object \
not working as expected for complex matrices
  `#3733 <https://github.com/scipy/scipy/issues/3733>`__: segfault from \
map_coordinates
  `#3780 <https://github.com/scipy/scipy/issues/3780>`__: Segfault when \
using CSR/CSC matrix and uint32/uint64
  `#3781 <https://github.com/scipy/scipy/pull/3781>`__: BUG: sparse: fix \
omitted types in sparsetools typemaps
  `#3802 <https://github.com/scipy/scipy/issues/3802>`__: 0.14.0 API \
breakage: _gen generators are missing from scipy.stats.distributions API
  `#3805 <https://github.com/scipy/scipy/issues/3805>`__: ndimage test \
failures with numpy 1.10
  `#3812 <https://github.com/scipy/scipy/issues/3812>`__: == sometimes \
wrong on csr_matrix
  `#3853 <https://github.com/scipy/scipy/issues/3853>`__: Many \
scipy.sparse test errors/failures with numpy 1.9.0b2
  `#4084 <https://github.com/scipy/scipy/pull/4084>`__: fix exception \
declarations for Cython 0.21.1 compatibility
  `#4093 <https://github.com/scipy/scipy/pull/4093>`__: BUG: fitpack: \
avoid a memory error in splev(x, tck, der=k)
  `#4104 <https://github.com/scipy/scipy/pull/4104>`__: BUG: Workaround \
SGEMV segfault in Accelerate (maintenance 0.14.x)
  `#4143 <https://github.com/scipy/scipy/pull/4143>`__: BUG: fix ndimage \
functions for large data
  `#4149 <https://github.com/scipy/scipy/issues/4149>`__: Bug in expm \
for integer arrays
  `#4154 <https://github.com/scipy/scipy/issues/4154>`__: Backport \
gh4041 for 0.14.1 (Ensure that the 'size' argument of PIL's 'resize' method is \
a tuple)
  `#4163 <https://github.com/scipy/scipy/issues/4163>`__: Backport #4142 \
(ZeroDivisionError in scipy.sparse.linalg.lsqr)
  `#4164 <https://github.com/scipy/scipy/issues/4164>`__: Backport \
gh4153 (remove use of deprecated numpy API in lib/lapack/ f2py wrapper)
  `#4180 <https://github.com/scipy/scipy/pull/4180>`__: backport pil \
resize support tuple fix
  `#4168 <https://github.com/scipy/scipy/issues/4168>`__: Lots of arpack \
test failures on windows 32 bits with numpy 1.9.1
  `#4203 <https://github.com/scipy/scipy/issues/4203>`__: Matrix \
multiplication in 0.14.x is more than 10x slower compared...
  `#4218 <https://github.com/scipy/scipy/pull/4218>`__: attempt to make \
ndimage interpolation compatible with numpy relaxed...
  `#4225 <https://github.com/scipy/scipy/pull/4225>`__: BUG: offbyone \
error in PPoly shape checks
  `#4248 <https://github.com/scipy/scipy/pull/4248>`__: BUG: optimize: \
fix issue with incorrect use of closure for slsqp.
SciPy 0.14.0 Release Notes
==========================
.. contents::
SciPy 0.14.0 is the culmination of 8 months of hard work. It contains
many new features, numerous bugfixes, 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 bugfixes and optimizations. Moreover, our development attention
will now shift to bugfix releases on the 0.14.x branch, and on adding
new features on the master branch.
This release requires Python 2.6, 2.7 or 3.23.4 and NumPy 1.5.1 or greater.
New features
============
``scipy.interpolate`` improvements

A new wrapper function `scipy.interpolate.interpn` for interpolation on regular
grids has been added. `interpn` supports linear and nearestneighbor
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 nonmonotonic 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 ksample
AndersonDarling 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 polezero ("zpk")
format internally instead of using transformations to numerator/denominator
format. The accuracy of the produced filters, especially highorder 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 BoxCox 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 64bit 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
distributionspecific ``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 complexvalued 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 2norm, 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 inplace
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.
SciPy 0.13.3 Release Notes
SciPy 0.13.3 is a bugfix release with no new features compared to 0.13.2. Both \
the weave and the ndimage.label bugs were severe regressions in 0.13.0, hence \
this release.
Issues fixed
3148: fix a memory leak in ndimage.label.
3216: fix weave issue with too long file names for MSVC.
Other changes
Update Sphinx theme used for html docs so >>> in examples can be \
toggled.
SciPy 0.13.2 Release Notes
SciPy 0.13.2 is a bugfix release with no new features compared to 0.13.1.
Issues fixed
3096: require Cython 0.19, earlier versions have memory leaks in fused types
3079: ndimage.label fix swapped 64bitness test
3108: optimize.fmin_slsqp constraint violation
SciPy 0.13.1 Release Notes
SciPy 0.13.1 is a bugfix release with no new features compared to 0.13.0. The \
only changes are several fixes in ndimage, one of which was a serious regression \
in ndimage.label (Github issue 3025), which gave incorrect results in 0.13.0.
Issues fixed
3025: ndimage.label returns incorrect results in scipy 0.13.0
1992: ndimage.label return type changed from int32 to uint32
1992: ndimage.find_objects doesn't work with int32 input in some cases
SciPy 0.13.0 Release Notes
==========================
.. contents::
SciPy 0.13.0 is the culmination of 7 months of hard work. It contains
many new features, numerous bugfixes, 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 bugfixes and optimizations. Moreover, our development attention
will now shift to bugfix releases on the 0.13.x branch, and on adding
new features on the master branch.
This release requires Python 2.6, 2.7 or 3.13.3 and NumPy 1.5.1 or greater.
Highlights of this release are:
 support for fancy indexing and boolean comparisons with sparse matrices
 interpolative decompositions and matrix functions in the linalg module
 two new trustregion solvers for unconstrained minimization
New features
============
``scipy.integrate`` improvements

Ndimensional numerical integration
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
A new function `scipy.integrate.nquad`, which provides Ndimensional
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 coauthors.
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

Trustregion unconstrained minimization algorithms
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The ``minimize`` function gained two trustregion solvers for unconstrained
minimization: ``dogleg`` and ``trustncg``.
``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 1norm 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 AlMohy
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 2D.
``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

Bspline derivatives and antiderivatives
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
`scipy.interpolate.splder` and `scipy.interpolate.splantider` functions
for computing Bsplines that represent derivatives and antiderivatives
of Bsplines were added. These functions are also available in the
classbased 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
CressieRead power divergence statistic and goodness of fit test.
Included in this family of statistics is the "Gtest"
(http://en.wikipedia.org/wiki/Gtest).
`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 fullfeatured 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 fullfeatured ``radon`` function in
scikitimage.
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.
Scipy cannot be compiled with gfortran 4.1 anymore (at least on RH5), likely
due to that compiler version not supporting entry constructs well.
