.
-Code Contributions:
-
-The main developers on SciPy are Travis Oliphant, Pearu Peterson, and Eric
-Jones. Travis and Eric each contributed about half the orginal code. Pearu
-developed f2py, which is the integral to wrapping the many Fortran libraries
-used in SciPy. All three continually work on both algorithm development and
-improvements to the feature set, build process, and robustness of SciPy.
-
Please add names as needed so that we can keep up with all the contributors.
Kumar Appaiah -- Dolph Chebyshev window
@@ -34,7 +30,7 @@
distance functions in spatial package, vq documentation
Anne Archibald -- kd-trees and nearest neighbor in scipy.spatial
Pauli Virtanen -- Sphinx documentation generation, interpolation bugfixes.
-Josef Pktd -- major improvements to scipy.stats and its test suite
+Josef Perktold -- major improvements to scipy.stats and its test suite
Testing:
From scipy-svn at scipy.org Tue Dec 16 06:04:10 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 16 Dec 2008 05:04:10 -0600 (CST)
Subject: [Scipy-svn] r5270 - trunk
Message-ID: <20081216110410.80F2AC7C02A@scipy.org>
Author: jarrod.millman
Date: 2008-12-16 05:04:08 -0600 (Tue, 16 Dec 2008)
New Revision: 5270
Modified:
trunk/THANKS.txt
Log:
more consistent with the NumPy Thanks
Modified: trunk/THANKS.txt
===================================================================
--- trunk/THANKS.txt 2008-12-16 10:46:27 UTC (rev 5269)
+++ trunk/THANKS.txt 2008-12-16 11:04:08 UTC (rev 5270)
@@ -11,49 +11,37 @@
Please add names as needed so that we can keep up with all the contributors.
-Kumar Appaiah -- Dolph Chebyshev window
-Nathan Bell -- sparsetools, help with scipy.sparse and scipy.splinalg
-Robert Cimrman -- UMFpack wrapper for sparse matrix module
-David M. Cooke -- improvements to system_info, and LBFGSB wrapper
-Aric Hagberg -- ARPACK wrappers, help with splinalg.eigen
-Chuck Harris -- Zeros package in optimize (1d root-finding algorithms)
-Prabhu Ramachandran -- improvements to gui_thread
-Robert Kern -- improvements to stats and bug-fixes
-Jean-Sebastien Roy -- fmin_tnc code which he adapted from Stephen Nash's
- original Fortran
-Ed Schofield -- Maximum entropy and Monte Carlo modules, help with
- sparse matrix module
-Travis Vaught -- initial work on stats module clean up
-Jeff Whitaker -- Mac OS X support
-David Cournapeau -- bug-fixes, refactor of fftpack and cluster, numscons build.
-Damian Eads -- hierarchical clustering, dendrogram plotting,
- distance functions in spatial package, vq documentation
-Anne Archibald -- kd-trees and nearest neighbor in scipy.spatial
-Pauli Virtanen -- Sphinx documentation generation, interpolation bugfixes.
-Josef Perktold -- major improvements to scipy.stats and its test suite
-
-Testing:
-
+Kumar Appaiah for Dolph Chebyshev window
+Nathan Bell for sparsetools, help with scipy.sparse and scipy.splinalg
+Robert Cimrman for UMFpack wrapper for sparse matrix module
+David M. Cooke for improvements to system_info, and LBFGSB wrapper
+Aric Hagberg for ARPACK wrappers, help with splinalg.eigen
+Chuck Harris for Zeros package in optimize (1d root-finding algorithms)
+Prabhu Ramachandran for improvements to gui_thread
+Robert Kern for improvements to stats and bug-fixes
+Jean-Sebastien Roy for fmin_tnc code which he adapted from Stephen Nash's
+ original Fortran
+Ed Schofield for Maximum entropy and Monte Carlo modules, help with
+ sparse matrix module
+Travis Vaught for numerous contributions to annual conference and community
+ web-site and the initial work on stats module clean up
+Jeff Whitaker for Mac OS X support
+David Cournapeau for bug-fixes, refactor of fftpack and cluster, numscons build.
+Damian Eads for hierarchical clustering, dendrogram plotting,
+ distance functions in spatial package, vq documentation
+Anne Archibald for kd-trees and nearest neighbor in scipy.spatial
+Pauli Virtanen for Sphinx documentation generation, interpolation bugfixes.
+Josef Perktold for major improvements to scipy.stats and its test suite
David Morrill for getting the scoreboard test system up and running.
Louis Luangkesorn for providing multiple tests for the stats module.
+Jochen Kupper for the zoom feature in the now-deprecated plt plotting module
+Tiffany Kamm for working on the community web-site.
+Mark Koudritsky for maintaining the web-site
+Andrew Straw for setting up the new Wiki at scipy.org
+Institutions
+------------
-Others:
-
-Others who have contributed in the past include:
-
-Jochen Kupper -- the zoom feature in the now-deprecated plt plotting module
-
-
-Website Development:
-
-Travis Vaught, Tiffany Kamm, and Eric Jones -- for building the community web-site.
-Travis Vaught, Mark Koudritsky -- for maintaining the web-site
-Andrew Straw -- for setting up the new Wiki at scipy.org
-
-
-Institutions:
-
Enthought -- for providing resources and finances for development of SciPy.
Brigham Young University -- for providing resources for students to work on SciPy.
Agilent -- which gave a genereous donation for support of SciPy.
From scipy-svn at scipy.org Tue Dec 16 06:27:00 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 16 Dec 2008 05:27:00 -0600 (CST)
Subject: [Scipy-svn] r5271 - trunk
Message-ID: <20081216112700.6D362C7C029@scipy.org>
Author: jarrod.millman
Date: 2008-12-16 05:26:58 -0600 (Tue, 16 Dec 2008)
New Revision: 5271
Modified:
trunk/THANKS.txt
Log:
added more contributors
Modified: trunk/THANKS.txt
===================================================================
--- trunk/THANKS.txt 2008-12-16 11:04:08 UTC (rev 5270)
+++ trunk/THANKS.txt 2008-12-16 11:26:58 UTC (rev 5271)
@@ -37,12 +37,20 @@
Jochen Kupper for the zoom feature in the now-deprecated plt plotting module
Tiffany Kamm for working on the community web-site.
Mark Koudritsky for maintaining the web-site
-Andrew Straw for setting up the new Wiki at scipy.org
+Andrew Straw for help with the web-page, documentation, packaging and
+ testing.
+Stefan van der Walt for numerous bug-fixes, testing and documentation.
+Jarrod Millman for release management, community coordination, and code
+ clean up.
+Pierre Gerard-Marchant for statistical masked array functionality.
+Alan McIntyre for updating SciPy tests to use the new NumPy test framework.
+
Institutions
------------
-Enthought -- for providing resources and finances for development of SciPy.
-Brigham Young University -- for providing resources for students to work on SciPy.
-Agilent -- which gave a genereous donation for support of SciPy.
+Enthought for providing resources and finances for development of SciPy.
+Brigham Young University for providing resources for students to work on SciPy.
+Agilent which gave a genereous donation for support of SciPy.
+UC Berkeley for providing travel money and hosting numerous sprints.
From scipy-svn at scipy.org Tue Dec 16 06:59:11 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 16 Dec 2008 05:59:11 -0600 (CST)
Subject: [Scipy-svn] r5272 - trunk
Message-ID: <20081216115911.B8A94C7C029@scipy.org>
Author: jarrod.millman
Date: 2008-12-16 05:59:09 -0600 (Tue, 16 Dec 2008)
New Revision: 5272
Modified:
trunk/THANKS.txt
Log:
more people to Thank
Modified: trunk/THANKS.txt
===================================================================
--- trunk/THANKS.txt 2008-12-16 11:26:58 UTC (rev 5271)
+++ trunk/THANKS.txt 2008-12-16 11:59:09 UTC (rev 5272)
@@ -44,8 +44,13 @@
clean up.
Pierre Gerard-Marchant for statistical masked array functionality.
Alan McIntyre for updating SciPy tests to use the new NumPy test framework.
+Matthew Brett for work on the Matlab file IO, bug-fixes, and improvements
+ to the testing framework.
+Gary Strangman for the scipy.stats package.
+Tiziano Zito for generalized symmetric and hermitian eigenvalue problem
+ solver.
+Chris Burns for bug-fixes.
-
Institutions
------------
From scipy-svn at scipy.org Tue Dec 16 20:37:24 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 16 Dec 2008 19:37:24 -0600 (CST)
Subject: [Scipy-svn] r5273 - trunk/doc/source/tutorial
Message-ID: <20081217013724.C9B3CC7C00F@scipy.org>
Author: david.warde-farley
Date: 2008-12-16 19:37:08 -0600 (Tue, 16 Dec 2008)
New Revision: 5273
Added:
trunk/doc/source/tutorial/ndimage.rst
Log:
Testing to see if I can commit.
Added: trunk/doc/source/tutorial/ndimage.rst
===================================================================
--- trunk/doc/source/tutorial/ndimage.rst 2008-12-16 11:59:09 UTC (rev 5272)
+++ trunk/doc/source/tutorial/ndimage.rst 2008-12-17 01:37:08 UTC (rev 5273)
@@ -0,0 +1,2 @@
+Multi-dimensional image processing
+==================================
From scipy-svn at scipy.org Wed Dec 17 21:51:49 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 17 Dec 2008 20:51:49 -0600 (CST)
Subject: [Scipy-svn] r5274 - trunk/scipy/optimize
Message-ID: <20081218025149.36A62C7C01D@scipy.org>
Author: josef
Date: 2008-12-17 20:51:45 -0600 (Wed, 17 Dec 2008)
New Revision: 5274
Modified:
trunk/scipy/optimize/__init__.py
trunk/scipy/optimize/info.py
Log:
add nnls to optimize __all__ and info
Modified: trunk/scipy/optimize/__init__.py
===================================================================
--- trunk/scipy/optimize/__init__.py 2008-12-17 01:37:08 UTC (rev 5273)
+++ trunk/scipy/optimize/__init__.py 2008-12-18 02:51:45 UTC (rev 5274)
@@ -14,6 +14,7 @@
from nonlin import broyden1, broyden2, broyden3, broyden_generalized, \
anderson, anderson2
from slsqp import fmin_slsqp
+from nnls import nnls
__all__ = filter(lambda s:not s.startswith('_'),dir())
from numpy.testing import Tester
Modified: trunk/scipy/optimize/info.py
===================================================================
--- trunk/scipy/optimize/info.py 2008-12-17 01:37:08 UTC (rev 5273)
+++ trunk/scipy/optimize/info.py 2008-12-18 02:51:45 UTC (rev 5274)
@@ -27,6 +27,9 @@
fmin_cobyla -- Constrained Optimization BY Linear Approximation
+ nnls -- Solve linear least squares problem with non-negativity
+ constraint
+
Global Optimizers::
anneal -- Simulated Annealing
From scipy-svn at scipy.org Thu Dec 18 15:32:27 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Thu, 18 Dec 2008 14:32:27 -0600 (CST)
Subject: [Scipy-svn] r5275 - in trunk/scipy/interpolate: . tests
Message-ID: <20081218203227.9EBCCC7C011@scipy.org>
Author: ptvirtan
Date: 2008-12-18 14:32:14 -0600 (Thu, 18 Dec 2008)
New Revision: 5275
Modified:
trunk/scipy/interpolate/interpolate.py
trunk/scipy/interpolate/tests/test_interpolate.py
Log:
interp1d/spleval: enable spline interpolation of complex-valued data, by evaluating real and imaginary parts separately
Modified: trunk/scipy/interpolate/interpolate.py
===================================================================
--- trunk/scipy/interpolate/interpolate.py 2008-12-18 02:51:45 UTC (rev 5274)
+++ trunk/scipy/interpolate/interpolate.py 2008-12-18 20:32:14 UTC (rev 5275)
@@ -248,9 +248,6 @@
self._call = self._call_spline
self._spline = splmake(x,oriented_y,order=order)
- if issubclass(y.dtype.type, np.complexfloating):
- raise ValueError("Input data must be real for spline interpolation")
-
len_x = len(x)
if len_x != len_y:
raise ValueError("x and y arrays must be equal in length along "
@@ -765,10 +762,14 @@
oldshape = np.shape(xnew)
xx = np.ravel(xnew)
sh = cvals.shape[1:]
- res = np.empty(xx.shape + sh)
+ res = np.empty(xx.shape + sh, dtype=cvals.dtype)
for index in np.ndindex(*sh):
sl = (slice(None),)+index
- res[sl] = _fitpack._bspleval(xx,xj,cvals[sl],k,deriv)
+ if issubclass(cvals.dtype.type, np.complexfloating):
+ res[sl].real = _fitpack._bspleval(xx,xj,cvals.real[sl],k,deriv)
+ res[sl].imag = _fitpack._bspleval(xx,xj,cvals.imag[sl],k,deriv)
+ else:
+ res[sl] = _fitpack._bspleval(xx,xj,cvals[sl],k,deriv)
res.shape = oldshape + sh
return res
Modified: trunk/scipy/interpolate/tests/test_interpolate.py
===================================================================
--- trunk/scipy/interpolate/tests/test_interpolate.py 2008-12-18 02:51:45 UTC (rev 5274)
+++ trunk/scipy/interpolate/tests/test_interpolate.py 2008-12-18 20:32:14 UTC (rev 5275)
@@ -292,35 +292,28 @@
yield self._nd_check_interp, kind
yield self._nd_check_shape, kind
- def _check_complex(self, dtype=np.complex_, kind='linear', fail=False):
- x = np.arange(10).astype(np.int_)
- y = np.arange(10).astype(np.int_) * (1 + 2j)
+ def _check_complex(self, dtype=np.complex_, kind='linear'):
+ x = np.array([1, 2.5, 3, 3.1, 4, 6.4, 7.9, 8.0, 9.5, 10])
+ y = x * x ** (1 + 2j)
y = y.astype(dtype)
- if fail:
- assert_raises(ValueError, interp1d, x, y, kind=kind)
- else:
- c = interp1d(x, y, kind=kind)
- assert_array_almost_equal(y[:-1], c(x)[:-1])
- assert (y.dtype == dtype) or not issubclass(y.dtype.type, np.inexact)
+ # simple test
+ c = interp1d(x, y, kind=kind)
+ assert_array_almost_equal(y[:-1], c(x)[:-1])
+
+ # check against interpolating real+imag separately
+ xi = np.linspace(1, 10, 31)
+ cr = interp1d(x, y.real, kind=kind)
+ ci = interp1d(x, y.imag, kind=kind)
+ assert_array_almost_equal(c(xi).real, cr(xi))
+ assert_array_almost_equal(c(xi).imag, ci(xi))
+
def test_complex(self):
- for kind in ('linear', 'nearest'):
+ for kind in ('linear', 'nearest', 'cubic', 'slinear', 'quadratic',
+ 'zero'):
yield self._check_complex, np.complex64, kind
yield self._check_complex, np.complex128, kind
- yield self._check_complex, np.float32, kind
- yield self._check_complex, np.float64, kind
- # The spline methods can't handle complex values, because the code
- # for _fitpack.bispleval is written in C and is not type-agnostic.
- #
- # Check that a ValueError is raised if one attempts to interpolate
- # complex data using these routines.
- for kind in ('cubic', 'slinear', 'quadratic', 'zero'):
- yield self._check_complex, np.complex64, kind, True
- yield self._check_complex, np.complex128, kind, True
- yield self._check_complex, np.float32, kind
- yield self._check_complex, np.float64, kind
-
@dec.knownfailureif(True, "zero-order splines fail for the last point")
def test_nd_zero_spline(self):
# zero-order splines don't get the last point right,
From scipy-svn at scipy.org Thu Dec 18 15:43:00 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Thu, 18 Dec 2008 14:43:00 -0600 (CST)
Subject: [Scipy-svn] r5276 - trunk/scipy/optimize/tests
Message-ID: <20081218204300.543BEC7C00B@scipy.org>
Author: ptvirtan
Date: 2008-12-18 14:42:29 -0600 (Thu, 18 Dec 2008)
New Revision: 5276
Modified:
trunk/scipy/optimize/tests/test_nnls.py
Log:
Adapt nnls test to changed import
Modified: trunk/scipy/optimize/tests/test_nnls.py
===================================================================
--- trunk/scipy/optimize/tests/test_nnls.py 2008-12-18 20:32:14 UTC (rev 5275)
+++ trunk/scipy/optimize/tests/test_nnls.py 2008-12-18 20:42:29 UTC (rev 5276)
@@ -16,7 +16,7 @@
a=arange(25.0).reshape(-1,5)
x=arange(5.0)
y=dot(a,x)
- x, res= nnls.nnls(a,y)
+ x, res= nnls(a,y)
assert res<1e-7
assert norm(dot(a,x)-y)<1e-7
From scipy-svn at scipy.org Thu Dec 18 18:50:26 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Thu, 18 Dec 2008 17:50:26 -0600 (CST)
Subject: [Scipy-svn] r5277 - trunk/doc/source/tutorial
Message-ID: <20081218235026.1157FC7C00B@scipy.org>
Author: david.warde-farley
Date: 2008-12-18 17:49:30 -0600 (Thu, 18 Dec 2008)
New Revision: 5277
Modified:
trunk/doc/source/tutorial/ndimage.rst
Log:
First pass at the conversion of the old numarray stuff. Sphinx references and some other roles are marked from available markup, stuff in {} need a careful look.
Modified: trunk/doc/source/tutorial/ndimage.rst
===================================================================
--- trunk/doc/source/tutorial/ndimage.rst 2008-12-18 20:42:29 UTC (rev 5276)
+++ trunk/doc/source/tutorial/ndimage.rst 2008-12-18 23:49:30 UTC (rev 5277)
@@ -1,2 +1,1805 @@
Multi-dimensional image processing
==================================
+
+{Peter Verveer} {verveer at users.sourceforge.net}
+{Multidimensional image analysis functions}
+
+.. _ndimage_introduction:
+
+Introduction
+============
+
+Image processing and analysis are generally seen as operations on
+two-dimensional arrays of values. There are however a number of
+fields where images of higher dimensionality must be analyzed. Good
+examples of these are medical imaging and biological imaging.
+{numarray} is suited very well for this type of applications due
+its inherent multi-dimensional nature. The {numarray.nd_image}
+packages provides a number of general image processing and analysis
+functions that are designed to operate with arrays of arbitrary
+dimensionality. The packages currently includes functions for
+linear and non-linear filtering, binary morphology, B-spline
+interpolation, and object measurements.
+
+.. _ndimage_properties_shared_by_all_functions:
+
+Properties shared by all functions
+==================================
+
+All functions share some common properties. Notably, all functions
+allow the specification of an output array with the {output}
+argument. With this argument you can specify an array that will be
+changed in-place with the result with the operation. In this case
+the result is not returned. Usually, using the {output} argument is
+more efficient, since an existing array is used to store the
+result.
+
+The type of arrays returned is dependent on the type of operation,
+but it is in most cases equal to the type of the input. If,
+however, the {output} argument is used, the type of the result is
+equal to the type of the specified output argument. If no output
+argument is given, it is still possible to specify what the result
+of the output should be. This is done by simply assigning the
+desired numarray type object to the output argument. For example:
+
+::
+
+ >>> print correlate(arange(10), [1, 2.5])
+ [ 0 2 6 9 13 16 20 23 27 30]
+ >>> print correlate(arange(10), [1, 2.5], output = Float64)
+ [ 0. 2.5 6. 9.5 13. 16.5 20. 23.5 27. 30.5]
+
+{In previous versions of :mod:`scipy.ndimage`, some functions accepted the *output_type* argument to achieve the same effect. This argument is still supported, but its use will generate an deprecation warning. In a future version all instances of this argument will be removed. The preferred way to specify an output type, is by using the *output* argument, either by specifying an output array of the desired type, or by specifying the type of the output that is to be returned.}
+
+Filter functions
+================
+
+.. _ndimage_filter_functions:
+
+The functions described in this section all perform some type of spatial filtering of the the input array: the elements in the output are some function of the values in the neighborhood of the corresponding input element. We refer to this neighborhood of elements as the filter kernel, which is often
+rectangular in shape but may also have an arbitrary footprint. Many
+of the functions described below allow you to define the footprint
+of the kernel, by passing a mask through the {footprint} parameter.
+For example a cross shaped kernel can be defined as follows:
+
+::
+
+ >>> footprint = array([[0,1,0],[1,1,1],[0,1,0]])
+ >>> print footprint
+ [[0 1 0]
+ [1 1 1]
+ [0 1 0]]
+
+Usually the origin of the kernel is at the center calculated by
+dividing the dimensions of the kernel shape by two. For instance,
+the origin of a one-dimensional kernel of length three is at the
+second element. Take for example the correlation of a
+one-dimensional array with a filter of length 3 consisting of
+ones:
+
+::
+
+ >>> a = [0, 0, 0, 1, 0, 0, 0]
+ >>> correlate1d(a, [1, 1, 1])
+ [0 0 1 1 1 0 0]
+
+Sometimes it is convenient to choose a different origin for the
+kernel. For this reason most functions support the {origin}
+parameter which gives the origin of the filter relative to its
+center. For example:
+
+::
+
+ >>> a = [0, 0, 0, 1, 0, 0, 0]
+ >>> print correlate1d(a, [1, 1, 1], origin = -1)
+ [0 1 1 1 0 0 0]
+
+The effect is a shift of the result towards the left. This feature
+will not be needed very often, but it may be useful especially for
+filters that have an even size. A good example is the calculation
+of backward and forward differences:
+
+::
+
+ >>> a = [0, 0, 1, 1, 1, 0, 0]
+ >>> print correlate1d(a, [-1, 1]) ## backward difference
+ [ 0 0 1 0 0 -1 0]
+ >>> print correlate1d(a, [-1, 1], origin = -1) ## forward difference
+ [ 0 1 0 0 -1 0 0]
+
+We could also have calculated the forward difference as follows:
+
+::
+
+ >>> print correlate1d(a, [0, -1, 1])
+ [ 0 1 0 0 -1 0 0]
+
+however, using the origin parameter instead of a larger kernel is
+more efficient. For multi-dimensional kernels {origin} can be a
+number, in which case the origin is assumed to be equal along all
+axes, or a sequence giving the origin along each axis.
+
+Since the output elements are a function of elements in the
+neighborhood of the input elements, the borders of the array need
+to be dealt with appropriately by providing the values outside the
+borders. This is done by assuming that the arrays are extended
+beyond their boundaries according certain boundary conditions. In
+the functions described below, the boundary conditions can be
+selected using the {mode} parameter which must be a string with the
+name of the boundary condition. Following boundary conditions are
+currently supported:
+
+ {"nearest"} {Use the value at the boundary} {[1 2 3]->[1 1 2 3 3]}
+ {"wrap"} {Periodically replicate the array} {[1 2 3]->[3 1 2 3 1]}
+ {"reflect"} {Reflect the array at the boundary}
+ {[1 2 3]->[1 1 2 3 3]}
+ {"constant"} {Use a constant value, default value is 0.0}
+ {[1 2 3]->[0 1 2 3 0]}
+
+
+The {"constant"} mode is special since it needs an additional
+parameter to specify the constant value that should be used.
+
+{The easiest way to implement such boundary conditions would be to
+copy the data to a larger array and extend the data at the borders
+according to the boundary conditions. For large arrays and large filter
+kernels, this would be very memory consuming, and the functions described
+below therefore use a different approach that does not require allocating
+large temporary buffers.}
+
+Correlation and convolution
+---------------------------
+
+ The {correlate1d} function calculates a one-dimensional correlation
+ along the given axis. The lines of the array along the given axis
+ are correlated with the given {weights}. The {weights} parameter
+ must be a one-dimensional sequences of numbers.
+
+
+ The function {correlate} implements multi-dimensional correlation
+ of the input array with a given kernel.
+
+
+ The {convolve1d} function calculates a one-dimensional convolution
+ along the given axis. The lines of the array along the given axis
+ are convoluted with the given {weights}. The {weights} parameter
+ must be a one-dimensional sequences of numbers.
+
+ {A convolution is essentially a correlation after mirroring the
+ kernel. As a result, the *origin* parameter behaves differently than
+ in the case of a correlation: the result is shifted in the opposite
+ directions.}
+
+ The function {convolve} implements multi-dimensional convolution of
+ the input array with a given kernel.
+
+ {A convolution is essentially a correlation after mirroring the
+ kernel. As a result, the *origin* parameter behaves differently than
+ in the case of a correlation: the results is shifted in the opposite
+ direction.}
+
+.. _ndimage_filter_functions_smoothing:
+
+Smoothing filters
+-----------------
+
+
+ The {gaussian_filter1d} function implements a one-dimensional
+ Gaussian filter. The standard-deviation of the Gaussian filter is
+ passed through the parameter {sigma}. Setting {order}=0 corresponds
+ to convolution with a Gaussian kernel. An order of 1, 2, or 3
+ corresponds to convolution with the first, second or third
+ derivatives of a Gaussian. Higher order derivatives are not
+ implemented.
+
+
+ The {gaussian_filter} function implements a multi-dimensional
+ Gaussian filter. The standard-deviations of the Gaussian filter
+ along each axis are passed through the parameter {sigma} as a
+ sequence or numbers. If {sigma} is not a sequence but a single
+ number, the standard deviation of the filter is equal along all
+ directions. The order of the filter can be specified separately for
+ each axis. An order of 0 corresponds to convolution with a Gaussian
+ kernel. An order of 1, 2, or 3 corresponds to convolution with the
+ first, second or third derivatives of a Gaussian. Higher order
+ derivatives are not implemented. The {order} parameter must be a
+ number, to specify the same order for all axes, or a sequence of
+ numbers to specify a different order for each axis.
+
+ {The multi-dimensional filter is implemented as a sequence of
+ one-dimensional Gaussian filters. The intermediate arrays are stored in
+ the same data type as the output. Therefore, for output types with a
+ lower precision, the results may be imprecise because intermediate
+ results may be stored with insufficient precision. This can be
+ prevented by specifying a more precise output type.}
+
+
+ The {uniform_filter1d} function calculates a one-dimensional
+ uniform filter of the given {size} along the given axis.
+
+
+ The {uniform_filter} implements a multi-dimensional uniform
+ filter. The sizes of the uniform filter are given for each axis as
+ a sequence of integers by the {size} parameter. If {size} is not a
+ sequence, but a single number, the sizes along all axis are assumed
+ to be equal.
+
+ {The multi-dimensional filter is implemented as a sequence of
+ one-dimensional uniform filters. The intermediate arrays are stored in
+ the same data type as the output. Therefore, for output types with a
+ lower precision, the results may be imprecise because intermediate
+ results may be stored with insufficient precision. This can be
+ prevented by specifying a
+ more precise output type.}
+
+
+Filters based on order statistics
+---------------------------------
+
+ The {minimum_filter1d} function calculates a one-dimensional
+ minimum filter of given {size} along the given axis.
+
+
+ The {maximum_filter1d} function calculates a one-dimensional
+ maximum filter of given {size} along the given axis.
+
+
+ The {minimum_filter} function calculates a multi-dimensional
+ minimum filter. Either the sizes of a rectangular kernel or the
+ footprint of the kernel must be provided. The {size} parameter, if
+ provided, must be a sequence of sizes or a single number in which
+ case the size of the filter is assumed to be equal along each axis.
+ The {footprint}, if provided, must be an array that defines the
+ shape of the kernel by its non-zero elements.
+
+
+ The {maximum_filter} function calculates a multi-dimensional
+ maximum filter. Either the sizes of a rectangular kernel or the
+ footprint of the kernel must be provided. The {size} parameter, if
+ provided, must be a sequence of sizes or a single number in which
+ case the size of the filter is assumed to be equal along each axis.
+ The {footprint}, if provided, must be an array that defines the
+ shape of the kernel by its non-zero elements.
+
+
+ The {rank_filter} function calculates a multi-dimensional rank
+ filter. The {rank} may be less then zero, i.e., {rank}=-1 indicates
+ the largest element. Either the sizes of a rectangular kernel or
+ the footprint of the kernel must be provided. The {size} parameter,
+ if provided, must be a sequence of sizes or a single number in
+ which case the size of the filter is assumed to be equal along each
+ axis. The {footprint}, if provided, must be an array that defines
+ the shape of the kernel by its non-zero elements.
+
+
+ The {percentile_filter} function calculates a multi-dimensional
+ percentile filter. The {percentile} may be less then zero, i.e.,
+ {percentile}=-20 equals {percentile}=80. Either the sizes of a
+ rectangular kernel or the footprint of the kernel must be provided.
+ The {size} parameter, if provided, must be a sequence of sizes or a
+ single number in which case the size of the filter is assumed to be
+ equal along each axis. The {footprint}, if provided, must be an
+ array that defines the shape of the kernel by its non-zero
+ elements.
+
+
+ The {median_filter} function calculates a multi-dimensional median
+ filter. Either the sizes of a rectangular kernel or the footprint
+ of the kernel must be provided. The {size} parameter, if provided,
+ must be a sequence of sizes or a single number in which case the
+ size of the filter is assumed to be equal along each axis. The
+ {footprint} if provided, must be an array that defines the shape of
+ the kernel by its non-zero elements.
+
+
+Derivatives
+-----------
+
+Derivative filters can be constructed in several ways. The function
+{gaussian_filter1d} described in section
+:ref:`_ndimage_filter_functions_smoothing` can be used to calculate
+derivatives along a given axis using the {order} parameter. Other
+derivative filters are the Prewitt and Sobel filters:
+
+ The {prewitt} function calculates a derivative along the given
+ axis.
+
+
+ The {sobel} function calculates a derivative along the given
+ axis.
+
+
+The Laplace filter is calculated by the sum of the second
+derivatives along all axes. Thus, different Laplace filters can be
+constructed using different second derivative functions. Therefore
+we provide a general function that takes a function argument to
+calculate the second derivative along a given direction and to
+construct the Laplace filter:
+
+ The function {generic_laplace} calculates a laplace filter using
+ the function passed through {derivative2} to calculate second
+ derivatives. The function {derivative2} should have the following
+ signature:
+
+ {derivative2(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
+
+ It should calculate the second derivative along the dimension
+ {axis}. If {output} is not {None} it should use that for the output
+ and return {None}, otherwise it should return the result. {mode},
+ {cval} have the usual meaning.
+
+ The {extra_arguments} and {extra_keywords} arguments can be used
+ to pass a tuple of extra arguments and a dictionary of named
+ arguments that are passed to {derivative2} at each call.
+
+ For example:
+
+ ::
+
+ >>> def d2(input, axis, output, mode, cval):
+ ... return correlate1d(input, [1, -2, 1], axis, output, mode, cval, 0)
+ ...
+ >>> a = zeros((5, 5))
+ >>> a[2, 2] = 1
+ >>> print generic_laplace(a, d2)
+ [[ 0 0 0 0 0]
+ [ 0 0 1 0 0]
+ [ 0 1 -4 1 0]
+ [ 0 0 1 0 0]
+ [ 0 0 0 0 0]]
+
+ To demonstrate the use of the {extra_arguments} argument we could
+ do:
+
+ ::
+
+ >>> def d2(input, axis, output, mode, cval, weights):
+ ... return correlate1d(input, weights, axis, output, mode, cval, 0,)
+ ...
+ >>> a = zeros((5, 5))
+ >>> a[2, 2] = 1
+ >>> print generic_laplace(a, d2, extra_arguments = ([1, -2, 1],))
+ [[ 0 0 0 0 0]
+ [ 0 0 1 0 0]
+ [ 0 1 -4 1 0]
+ [ 0 0 1 0 0]
+ [ 0 0 0 0 0]]
+
+ or:
+
+ ::
+
+ >>> print generic_laplace(a, d2, extra_keywords = {'weights': [1, -2, 1]})
+ [[ 0 0 0 0 0]
+ [ 0 0 1 0 0]
+ [ 0 1 -4 1 0]
+ [ 0 0 1 0 0]
+ [ 0 0 0 0 0]]
+
+
+The following two functions are implemented using
+{generic_laplace} by providing appropriate functions for the
+second derivative function:
+
+ The function {laplace} calculates the Laplace using discrete
+ differentiation for the second derivative (i.e. convolution with
+ {[1, -2, 1]}).
+
+
+ The function {gaussian_laplace} calculates the Laplace using
+ {gaussian_filter} to calculate the second derivatives. The
+ standard-deviations of the Gaussian filter along each axis are
+ passed through the parameter {sigma} as a sequence or numbers. If
+ {sigma} is not a sequence but a single number, the standard
+ deviation of the filter is equal along all directions.
+
+
+The gradient magnitude is defined as the square root of the sum of
+the squares of the gradients in all directions. Similar to the
+generic Laplace function there is a {generic_gradient_magnitude}
+function that calculated the gradient magnitude of an array:
+
+ The function {generic_gradient_magnitude} calculates a gradient
+ magnitude using the function passed through {derivative} to
+ calculate first derivatives. The function {derivative} should have
+ the following signature:
+
+ {derivative(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
+
+ It should calculate the derivative along the dimension {axis}. If
+ {output} is not {None} it should use that for the output and return
+ {None}, otherwise it should return the result. {mode}, {cval} have
+ the usual meaning.
+
+ The {extra_arguments} and {extra_keywords} arguments can be used
+ to pass a tuple of extra arguments and a dictionary of named
+ arguments that are passed to {derivative} at each call.
+
+ For example, the {sobel} function fits the required signature:
+
+ ::
+
+ >>> a = zeros((5, 5))
+ >>> a[2, 2] = 1
+ >>> print generic_gradient_magnitude(a, sobel)
+ [[0 0 0 0 0]
+ [0 1 2 1 0]
+ [0 2 0 2 0]
+ [0 1 2 1 0]
+ [0 0 0 0 0]]
+
+ See the documentation of {generic_laplace} for examples of using
+ the {extra_arguments} and {extra_keywords} arguments.
+
+
+The {sobel} and {prewitt} functions fit the required signature and
+can therefore directly be used with {generic_gradient_magnitude}.
+The following function implements the gradient magnitude using
+Gaussian derivatives:
+
+ The function {gaussian_gradient_magnitude} calculates the
+ gradient magnitude using {gaussian_filter} to calculate the first
+ derivatives. The standard-deviations of the Gaussian filter along
+ each axis are passed through the parameter {sigma} as a sequence or
+ numbers. If {sigma} is not a sequence but a single number, the
+ standard deviation of the filter is equal along all directions.
+
+
+Generic filter functions
+------------------------
+
+.. _ndimage_genericfilters:
+
+To implement filter functions, generic functions can be used that accept a
+callable object that implements the filtering operation. The iteration over the
+input and output arrays is handled by these generic functions, along with such
+details as the implementation of the boundary conditions. Only a
+callable object implementing a callback function that does the
+actual filtering work must be provided. The callback function can
+also be written in C and passed using a CObject (see
+:ref:`_ndimage_ccallbacks` for more information).
+
+ The {generic_filter1d} function implements a generic
+ one-dimensional filter function, where the actual filtering
+ operation must be supplied as a python function (or other callable
+ object). The {generic_filter1d} function iterates over the lines
+ of an array and calls {function} at each line. The arguments that
+ are passed to {function} are one-dimensional arrays of the
+ {tFloat64} type. The first contains the values of the current line.
+ It is extended at the beginning end the end, according to the
+ {filter_size} and {origin} arguments. The second array should be
+ modified in-place to provide the output values of the line. For
+ example consider a correlation along one dimension:
+
+ ::
+
+ >>> a = arange(12, shape = (3,4))
+ >>> print correlate1d(a, [1, 2, 3])
+ [[ 3 8 14 17]
+ [27 32 38 41]
+ [51 56 62 65]]
+
+ The same operation can be implemented using {generic_filter1d} as
+ follows:
+
+ ::
+
+ >>> def fnc(iline, oline):
+ ... oline[...] = iline[:-2] + 2 * iline[1:-1] + 3 * iline[2:]
+ ...
+ >>> print generic_filter1d(a, fnc, 3)
+ [[ 3 8 14 17]
+ [27 32 38 41]
+ [51 56 62 65]]
+
+ Here the origin of the kernel was (by default) assumed to be in the
+ middle of the filter of length 3. Therefore, each input line was
+ extended by one value at the beginning and at the end, before the
+ function was called.
+
+ Optionally extra arguments can be defined and passed to the filter
+ function. The {extra_arguments} and {extra_keywords} arguments
+ can be used to pass a tuple of extra arguments and/or a dictionary
+ of named arguments that are passed to derivative at each call. For
+ example, we can pass the parameters of our filter as an argument:
+
+ ::
+
+ >>> def fnc(iline, oline, a, b):
+ ... oline[...] = iline[:-2] + a * iline[1:-1] + b * iline[2:]
+ ...
+ >>> print generic_filter1d(a, fnc, 3, extra_arguments = (2, 3))
+ [[ 3 8 14 17]
+ [27 32 38 41]
+ [51 56 62 65]]
+
+ or
+
+ ::
+
+ >>> print generic_filter1d(a, fnc, 3, extra_keywords = {'a':2, 'b':3})
+ [[ 3 8 14 17]
+ [27 32 38 41]
+ [51 56 62 65]]
+
+
+ The {generic_filter} function implements a generic filter
+ function, where the actual filtering operation must be supplied as
+ a python function (or other callable object). The {generic_filter}
+ function iterates over the array and calls {function} at each
+ element. The argument of {function} is a one-dimensional array of
+ the {tFloat64} type, that contains the values around the current
+ element that are within the footprint of the filter. The function
+ should return a single value that can be converted to a double
+ precision number. For example consider a correlation:
+
+ ::
+
+ >>> a = arange(12, shape = (3,4))
+ >>> print correlate(a, [[1, 0], [0, 3]])
+ [[ 0 3 7 11]
+ [12 15 19 23]
+ [28 31 35 39]]
+
+ The same operation can be implemented using {generic_filter} as
+ follows:
+
+ ::
+
+ >>> def fnc(buffer):
+ ... return (buffer * array([1, 3])).sum()
+ ...
+ >>> print generic_filter(a, fnc, footprint = [[1, 0], [0, 1]])
+ [[ 0 3 7 11]
+ [12 15 19 23]
+ [28 31 35 39]]
+
+ Here a kernel footprint was specified that contains only two
+ elements. Therefore the filter function receives a buffer of length
+ equal to two, which was multiplied with the proper weights and the
+ result summed.
+
+ When calling {generic_filter}, either the sizes of a rectangular
+ kernel or the footprint of the kernel must be provided. The {size}
+ parameter, if provided, must be a sequence of sizes or a single
+ number in which case the size of the filter is assumed to be equal
+ along each axis. The {footprint}, if provided, must be an array
+ that defines the shape of the kernel by its non-zero elements.
+
+ Optionally extra arguments can be defined and passed to the filter
+ function. The {extra_arguments} and {extra_keywords} arguments
+ can be used to pass a tuple of extra arguments and/or a dictionary
+ of named arguments that are passed to derivative at each call. For
+ example, we can pass the parameters of our filter as an argument:
+
+ ::
+
+ >>> def fnc(buffer, weights):
+ ... weights = asarray(weights)
+ ... return (buffer * weights).sum()
+ ...
+ >>> print generic_filter(a, fnc, footprint = [[1, 0], [0, 1]], extra_arguments = ([1, 3],))
+ [[ 0 3 7 11]
+ [12 15 19 23]
+ [28 31 35 39]]
+
+ or
+
+ ::
+
+ >>> print generic_filter(a, fnc, footprint = [[1, 0], [0, 1]], extra_keywords= {'weights': [1, 3]})
+ [[ 0 3 7 11]
+ [12 15 19 23]
+ [28 31 35 39]]
+
+
+These functions iterate over the lines or elements starting at the
+last axis, i.e. the last index changest the fastest. This order of
+iteration is garantueed for the case that it is important to adapt
+the filter dependening on spatial location. Here is an example of
+using a class that implements the filter and keeps track of the
+current coordinates while iterating. It performs the same filter
+operation as described above for {generic_filter}, but
+additionally prints the current coordinates:
+
+::
+
+ >>> a = arange(12, shape = (3,4))
+ >>>
+ >>> class fnc_class:
+ ... def __init__(self, shape):
+ ... # store the shape:
+ ... self.shape = shape
+ ... # initialize the coordinates:
+ ... self.coordinates = [0] * len(shape)
+ ...
+ ... def filter(self, buffer):
+ ... result = (buffer * array([1, 3])).sum()
+ ... print self.coordinates
+ ... # calculate the next coordinates:
+ ... axes = range(len(self.shape))
+ ... axes.reverse()
+ ... for jj in axes:
+ ... if self.coordinates[jj] < self.shape[jj] - 1:
+ ... self.coordinates[jj] += 1
+ ... break
+ ... else:
+ ... self.coordinates[jj] = 0
+ ... return result
+ ...
+ >>> fnc = fnc_class(shape = (3,4))
+ >>> print generic_filter(a, fnc.filter, footprint = [[1, 0], [0, 1]])
+ [0, 0]
+ [0, 1]
+ [0, 2]
+ [0, 3]
+ [1, 0]
+ [1, 1]
+ [1, 2]
+ [1, 3]
+ [2, 0]
+ [2, 1]
+ [2, 2]
+ [2, 3]
+ [[ 0 3 7 11]
+ [12 15 19 23]
+ [28 31 35 39]]
+
+For the {generic_filter1d} function the same approach works,
+except that this function does not iterate over the axis that is
+being filtered. The example for {generic_filte1d} then becomes
+this:
+
+::
+
+ >>> a = arange(12, shape = (3,4))
+ >>>
+ >>> class fnc1d_class:
+ ... def __init__(self, shape, axis = -1):
+ ... # store the filter axis:
+ ... self.axis = axis
+ ... # store the shape:
+ ... self.shape = shape
+ ... # initialize the coordinates:
+ ... self.coordinates = [0] * len(shape)
+ ...
+ ... def filter(self, iline, oline):
+ ... oline[...] = iline[:-2] + 2 * iline[1:-1] + 3 * iline[2:]
+ ... print self.coordinates
+ ... # calculate the next coordinates:
+ ... axes = range(len(self.shape))
+ ... # skip the filter axis:
+ ... del axes[self.axis]
+ ... axes.reverse()
+ ... for jj in axes:
+ ... if self.coordinates[jj] < self.shape[jj] - 1:
+ ... self.coordinates[jj] += 1
+ ... break
+ ... else:
+ ... self.coordinates[jj] = 0
+ ...
+ >>> fnc = fnc1d_class(shape = (3,4))
+ >>> print generic_filter1d(a, fnc.filter, 3)
+ [0, 0]
+ [1, 0]
+ [2, 0]
+ [[ 3 8 14 17]
+ [27 32 38 41]
+ [51 56 62 65]]
+
+Fourier domain filters
+======================
+
+The functions described in this section perform filtering
+operations in the Fourier domain. Thus, the input array of such a
+function should be compatible with an inverse Fourier transform
+function, such as the functions from the {numarray.fft} module. We
+therefore have to deal with arrays that may be the result of a real
+or a complex Fourier transform. In the case of a real Fourier
+transform only half of the of the symmetric complex transform is
+stored. Additionally, it needs to be known what the length of the
+axis was that was transformed by the real fft. The functions
+described here provide a parameter {n} that in the case of a real
+transform must be equal to the length of the real transform axis
+before transformation. If this parameter is less than zero, it is
+assumed that the input array was the result of a complex Fourier
+transform. The parameter {axis} can be used to indicate along which
+axis the real transform was executed.
+
+ The {fourier_shift} function multiplies the input array with the
+ multi-dimensional Fourier transform of a shift operation for the
+ given shift. The {shift} parameter is a sequences of shifts for
+ each dimension, or a single value for all dimensions.
+
+
+ The {fourier_gaussian} function multiplies the input array with
+ the multi-dimensional Fourier transform of a Gaussian filter with
+ given standard-deviations {sigma}. The {sigma} parameter is a
+ sequences of values for each dimension, or a single value for all
+ dimensions.
+
+
+ The {fourier_uniform} function multiplies the input array with the
+ multi-dimensional Fourier transform of a uniform filter with given
+ sizes {size}. The {size} parameter is a sequences of values for
+ each dimension, or a single value for all dimensions.
+
+
+ The {fourier_ellipsoid} function multiplies the input array with
+ the multi-dimensional Fourier transform of a elliptically shaped
+ filter with given sizes {size}. The {size} parameter is a sequences
+ of values for each dimension, or a single value for all dimensions.
+ {This function is
+ only implemented for dimensions 1, 2, and 3.}
+
+
+Interpolation functions
+=======================
+
+This section describes various interpolation functions that are
+based on B-spline theory. A good introduction to B-splines can be
+found in: M. Unser, "Splines: A Perfect Fit for Signal and Image
+Processing," IEEE Signal Processing Magazine, vol. 16, no. 6, pp.
+22-38, November 1999. {Spline pre-filters} Interpolation using
+splines of an order larger than 1 requires a pre- filtering step.
+The interpolation functions described in section
+:ref:`_ndimage_interpolation` apply pre-filtering by calling
+{spline_filter}, but they can be instructed not to do this by
+setting the {prefilter} keyword equal to {False}. This is useful if
+more than one interpolation operation is done on the same array. In
+this case it is more efficient to do the pre-filtering only once
+and use a prefiltered array as the input of the interpolation
+functions. The following two functions implement the
+pre-filtering:
+
+ The {spline_filter1d} function calculates a one-dimensional spline
+ filter along the given axis. An output array can optionally be
+ provided. The order of the spline must be larger then 1 and less
+ than 6.
+
+
+ The {spline_filter} function calculates a multi-dimensional spline
+ filter.
+
+ {The multi-dimensional filter is implemented as a sequence of
+ one-dimensional spline filters. The intermediate arrays are stored in
+ the same data type as the output. Therefore, if an output
+ with a limited precision is requested, the results may be imprecise
+ because intermediate results may be stored with insufficient precision.
+ This can be prevented by specifying a output type of high precision.}
+
+
+Interpolation functions
+-----------------------
+
+.. _ndimage_interpolation:
+
+Following functions all employ spline interpolation to effect some type of
+geometric transformation of the input array. This requires a mapping of the
+output coordinates to the input coordinates, and therefore the possibility
+arises that input values outside the boundaries are needed. This problem is
+solved in the same way as described in section :ref:`_ndimage_filter_functions`
+for the multi-dimensional filter functions. Therefore these functions all
+support a {mode} parameter that determines how the boundaries are handled, and
+a {cval} parameter that gives a constant value in case that the {'constant'}
+mode is used.
+
+ The {geometric_transform} function applies an arbitrary geometric
+ transform to the input. The given {mapping} function is called at
+ each point in the output to find the corresponding coordinates in
+ the input. {mapping} must be a callable object that accepts a tuple
+ of length equal to the output array rank and returns the
+ corresponding input coordinates as a tuple of length equal to the
+ input array rank. The output shape and output type can optionally
+ be provided. If not given they are equal to the input shape and
+ type.
+
+ For example:
+
+ ::
+
+ >>> a = arange(12, shape=(4,3), type = Float64)
+ >>> def shift_func(output_coordinates):
+ ... return (output_coordinates[0] - 0.5, output_coordinates[1] - 0.5)
+ ...
+ >>> print geometric_transform(a, shift_func)
+ [[ 0. 0. 0. ]
+ [ 0. 1.3625 2.7375]
+ [ 0. 4.8125 6.1875]
+ [ 0. 8.2625 9.6375]]
+
+ Optionally extra arguments can be defined and passed to the filter
+ function. The {extra_arguments} and {extra_keywords} arguments
+ can be used to pass a tuple of extra arguments and/or a dictionary
+ of named arguments that are passed to derivative at each call. For
+ example, we can pass the shifts in our example as arguments:
+
+ ::
+
+ >>> def shift_func(output_coordinates, s0, s1):
+ ... return (output_coordinates[0] - s0, output_coordinates[1] - s1)
+ ...
+ >>> print geometric_transform(a, shift_func, extra_arguments = (0.5, 0.5))
+ [[ 0. 0. 0. ]
+ [ 0. 1.3625 2.7375]
+ [ 0. 4.8125 6.1875]
+ [ 0. 8.2625 9.6375]]
+
+ or
+
+ ::
+
+ >>> print geometric_transform(a, shift_func, extra_keywords = {'s0': 0.5, 's1': 0.5})
+ [[ 0. 0. 0. ]
+ [ 0. 1.3625 2.7375]
+ [ 0. 4.8125 6.1875]
+ [ 0. 8.2625 9.6375]]
+
+ {The mapping function can also be written in C and passed using a CObject. See :ref:`_ndimage_ccallbacks` for more information.}
+
+
+ The function {map_coordinates} applies an arbitrary coordinate
+ transformation using the given array of coordinates. The shape of
+ the output is derived from that of the coordinate array by dropping
+ the first axis. The parameter {coordinates} is used to find for
+ each point in the output the corresponding coordinates in the
+ input. The values of {coordinates} along the first axis are the
+ coordinates in the input array at which the output value is found.
+ (See also the numarray {coordinates} function.) Since the
+ coordinates may be non- integer coordinates, the value of the input
+ at these coordinates is determined by spline interpolation of the
+ requested order. Here is an example that interpolates a 2D array at
+ (0.5, 0.5) and (1, 2):
+
+ ::
+
+ >>> a = arange(12, shape=(4,3), type = numarray.Float64)
+ >>> print a
+ [[ 0. 1. 2.]
+ [ 3. 4. 5.]
+ [ 6. 7. 8.]
+ [ 9. 10. 11.]]
+ >>> print map_coordinates(a, [[0.5, 2], [0.5, 1]])
+ [ 1.3625 7. ]
+
+
+ The {affine_transform} function applies an affine transformation
+ to the input array. The given transformation {matrix} and {offset}
+ are used to find for each point in the output the corresponding
+ coordinates in the input. The value of the input at the calculated
+ coordinates is determined by spline interpolation of the requested
+ order. The transformation {matrix} must be two-dimensional or can
+ also be given as a one-dimensional sequence or array. In the latter
+ case, it is assumed that the matrix is diagonal. A more efficient
+ interpolation algorithm is then applied that exploits the
+ separability of the problem. The output shape and output type can
+ optionally be provided. If not given they are equal to the input
+ shape and type.
+
+
+ The {shift} function returns a shifted version of the input, using
+ spline interpolation of the requested {order}.
+
+
+ The {zoom} function returns a rescaled version of the input, using
+ spline interpolation of the requested {order}.
+
+
+ The {rotate} function returns the input array rotated in the plane
+ defined by the two axes given by the parameter {axes}, using spline
+ interpolation of the requested {order}. The angle must be given in
+ degrees. If {reshape} is true, then the size of the output array is
+ adapted to contain the rotated input.
+
+
+Binary morphology
+=================
+
+.. _ndimage_binary_morphology:
+
+ The {generate_binary_structure} functions generates a binary
+ structuring element for use in binary morphology operations. The
+ {rank} of the structure must be provided. The size of the structure
+ that is returned is equal to three in each direction. The value of
+ each element is equal to one if the square of the Euclidean
+ distance from the element to the center is less or equal to
+ {connectivity}. For instance, two dimensional 4-connected and
+ 8-connected structures are generated as follows:
+
+ ::
+
+ >>> print generate_binary_structure(2, 1)
+ [[0 1 0]
+ [1 1 1]
+ [0 1 0]]
+ >>> print generate_binary_structure(2, 2)
+ [[1 1 1]
+ [1 1 1]
+ [1 1 1]]
+
+
+Most binary morphology functions can be expressed in terms of the
+basic operations erosion and dilation:
+
+ The {binary_erosion} function implements binary erosion of arrays
+ of arbitrary rank with the given structuring element. The origin
+ parameter controls the placement of the structuring element as
+ described in section :ref:`_ndimage_filter_functions`. If no
+ structuring element is provided, an element with connectivity equal
+ to one is generated using {generate_binary_structure}. The
+ {border_value} parameter gives the value of the array outside
+ boundaries. The erosion is repeated {iterations} times. If
+ {iterations} is less than one, the erosion is repeated until the
+ result does not change anymore. If a {mask} array is given, only
+ those elements with a true value at the corresponding mask element
+ are modified at each iteration.
+
+
+ The {binary_dilation} function implements binary dilation of
+ arrays of arbitrary rank with the given structuring element. The
+ origin parameter controls the placement of the structuring element
+ as described in section :ref:`_ndimage_filter_functions`. If no
+ structuring element is provided, an element with connectivity equal
+ to one is generated using {generate_binary_structure}. The
+ {border_value} parameter gives the value of the array outside
+ boundaries. The dilation is repeated {iterations} times. If
+ {iterations} is less than one, the dilation is repeated until the
+ result does not change anymore. If a {mask} array is given, only
+ those elements with a true value at the corresponding mask element
+ are modified at each iteration.
+
+ Here is an example of using {binary_dilation} to find all elements
+ that touch the border, by repeatedly dilating an empty array from
+ the border using the data array as the mask:
+
+ ::
+
+ >>> struct = array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
+ >>> a = array([[1,0,0,0,0], [1,1,0,1,0], [0,0,1,1,0], [0,0,0,0,0]])
+ >>> print a
+ [[1 0 0 0 0]
+ [1 1 0 1 0]
+ [0 0 1 1 0]
+ [0 0 0 0 0]]
+ >>> print binary_dilation(zeros(a.shape), struct, -1, a, border_value=1)
+ [[1 0 0 0 0]
+ [1 1 0 0 0]
+ [0 0 0 0 0]
+ [0 0 0 0 0]]
+
+
+The {binary_erosion} and {binary_dilation} functions both have an
+{iterations} parameter which allows the erosion or dilation to be
+repeated a number of times. Repeating an erosion or a dilation with
+a given structure {n} times is equivalent to an erosion or a
+dilation with a structure that is {n-1} times dilated with itself.
+A function is provided that allows the calculation of a structure
+that is dilated a number of times with itself:
+
+ The {iterate_structure} function returns a structure by dilation
+ of the input structure {iteration} - 1 times with itself. For
+ instance:
+
+ ::
+
+ >>> struct = generate_binary_structure(2, 1)
+ >>> print struct
+ [[0 1 0]
+ [1 1 1]
+ [0 1 0]]
+ >>> print iterate_structure(struct, 2)
+ [[0 0 1 0 0]
+ [0 1 1 1 0]
+ [1 1 1 1 1]
+ [0 1 1 1 0]
+ [0 0 1 0 0]]
+
+ If the origin of the original structure is equal to 0, then it is
+ also equal to 0 for the iterated structure. If not, the origin must
+ also be adapted if the equivalent of the {iterations} erosions or
+ dilations must be achieved with the iterated structure. The adapted
+ origin is simply obtained by multiplying with the number of
+ iterations. For convenience the {iterate_structure} also returns
+ the adapted origin if the {origin} parameter is not {None}:
+
+ ::
+
+ >>> print iterate_structure(struct, 2, -1)
+ (array([[0, 0, 1, 0, 0],
+ [0, 1, 1, 1, 0],
+ [1, 1, 1, 1, 1],
+ [0, 1, 1, 1, 0],
+ [0, 0, 1, 0, 0]], type=Bool), [-2, -2])
+
+
+Other morphology operations can be defined in terms of erosion and
+d dilation. Following functions provide a few of these operations
+for convenience:
+
+ The {binary_opening} function implements binary opening of arrays
+ of arbitrary rank with the given structuring element. Binary
+ opening is equivalent to a binary erosion followed by a binary
+ dilation with the same structuring element. The origin parameter
+ controls the placement of the structuring element as described in
+ section :ref:`_ndimage_filter_functions`. If no structuring element is
+ provided, an element with connectivity equal to one is generated
+ using {generate_binary_structure}. The {iterations} parameter
+ gives the number of erosions that is performed followed by the same
+ number of dilations.
+
+
+ The {binary_closing} function implements binary closing of arrays
+ of arbitrary rank with the given structuring element. Binary
+ closing is equivalent to a binary dilation followed by a binary
+ erosion with the same structuring element. The origin parameter
+ controls the placement of the structuring element as described in
+ section :ref:`_ndimage_filter_functions`. If no structuring element is
+ provided, an element with connectivity equal to one is generated
+ using {generate_binary_structure}. The {iterations} parameter
+ gives the number of dilations that is performed followed by the
+ same number of erosions.
+
+
+ The {binary_fill_holes} function is used to close holes in
+ objects in a binary image, where the structure defines the
+ connectivity of the holes. The origin parameter controls the
+ placement of the structuring element as described in section
+ :ref:`_ndimage_filter_functions`. If no structuring element is
+ provided, an element with connectivity equal to one is generated
+ using {generate_binary_structure}.
+
+
+ The {binary_hit_or_miss} function implements a binary
+ hit-or-miss transform of arrays of arbitrary rank with the given
+ structuring elements. The hit-or-miss transform is calculated by
+ erosion of the input with the first structure, erosion of the
+ logical *not* of the input with the second structure, followed by
+ the logical *and* of these two erosions. The origin parameters
+ control the placement of the structuring elements as described in
+ section :ref:`_ndimage_filter_functions`. If {origin2} equals {None} it
+ is set equal to the {origin1} parameter. If the first structuring
+ element is not provided, a structuring element with connectivity
+ equal to one is generated using {generate_binary_structure}, if
+ {structure2} is not provided, it is set equal to the logical *not*
+ of {structure1}.
+
+
+Grey-scale morphology
+=====================
+
+.. _ndimage_grey_morphology:
+
+
+
+Grey-scale morphology operations are the equivalents of binary
+morphology operations that operate on arrays with arbitrary values.
+Below we describe the grey-scale equivalents of erosion, dilation,
+opening and closing. These operations are implemented in a similar
+fashion as the filters described in section
+:ref:`_ndimage_filter_functions`, and we refer to this section for the
+description of filter kernels and footprints, and the handling of
+array borders. The grey-scale morphology operations optionally take
+a {structure} parameter that gives the values of the structuring
+element. If this parameter is not given the structuring element is
+assumed to be flat with a value equal to zero. The shape of the
+structure can optionally be defined by the {footprint} parameter.
+If this parameter is not given, the structure is assumed to be
+rectangular, with sizes equal to the dimensions of the {structure}
+array, or by the {size} parameter if {structure} is not given. The
+{size} parameter is only used if both {structure} and {footprint}
+are not given, in which case the structuring element is assumed to
+be rectangular and flat with the dimensions given by {size}. The
+{size} parameter, if provided, must be a sequence of sizes or a
+single number in which case the size of the filter is assumed to be
+equal along each axis. The {footprint} parameter, if provided, must
+be an array that defines the shape of the kernel by its non-zero
+elements.
+
+Similar to binary erosion and dilation there are operations for
+grey-scale erosion and dilation:
+
+ The {grey_erosion} function calculates a multi-dimensional grey-
+ scale erosion.
+
+
+ The {grey_dilation} function calculates a multi-dimensional grey-
+ scale dilation.
+
+
+Grey-scale opening and closing operations can be defined similar to
+their binary counterparts:
+
+ The {grey_opening} function implements grey-scale opening of
+ arrays of arbitrary rank. Grey-scale opening is equivalent to a
+ grey-scale erosion followed by a grey-scale dilation.
+
+
+ The {grey_closing} function implements grey-scale closing of
+ arrays of arbitrary rank. Grey-scale opening is equivalent to a
+ grey-scale dilation followed by a grey-scale erosion.
+
+
+ The {morphological_gradient} function implements a grey-scale
+ morphological gradient of arrays of arbitrary rank. The grey-scale
+ morphological gradient is equal to the difference of a grey-scale
+ dilation and a grey-scale erosion.
+
+
+ The {morphological_laplace} function implements a grey-scale
+ morphological laplace of arrays of arbitrary rank. The grey-scale
+ morphological laplace is equal to the sum of a grey-scale dilation
+ and a grey-scale erosion minus twice the input.
+
+
+ The {white_tophat} function implements a white top-hat filter of
+ arrays of arbitrary rank. The white top-hat is equal to the
+ difference of the input and a grey-scale opening.
+
+
+ The {black_tophat} function implements a black top-hat filter of
+ arrays of arbitrary rank. The black top-hat is equal to the
+ difference of the a grey-scale closing and the input.
+
+
+Distance transforms
+===================
+
+.. _ndimage_distance_transforms:
+
+Distance transforms are used to
+calculate the minimum distance from each element of an object to
+the background. The following functions implement distance
+transforms for three different distance metrics: Euclidean, City
+Block, and Chessboard distances.
+
+ The function {distance_transform_cdt} uses a chamfer type
+ algorithm to calculate the distance transform of the input, by
+ replacing each object element (defined by values larger than zero)
+ with the shortest distance to the background (all non-object
+ elements). The structure determines the type of chamfering that is
+ done. If the structure is equal to 'cityblock' a structure is
+ generated using {generate_binary_structure} with a squared
+ distance equal to 1. If the structure is equal to 'chessboard', a
+ structure is generated using {generate_binary_structure} with a
+ squared distance equal to the rank of the array. These choices
+ correspond to the common interpretations of the cityblock and the
+ chessboard distancemetrics in two dimensions.
+
+ In addition to the distance transform, the feature transform can be
+ calculated. In this case the index of the closest background
+ element is returned along the first axis of the result. The
+ {return_distances}, and {return_indices} flags can be used to
+ indicate if the distance transform, the feature transform, or both
+ must be returned.
+
+ The {distances} and {indices} arguments can be used to give
+ optional output arrays that must be of the correct size and type
+ (both {Int32}).
+
+ The basics of the algorithm used to implement this function is
+ described in: G. Borgefors, "Distance transformations in arbitrary
+ dimensions.", Computer Vision, Graphics, and Image Processing,
+ 27:321-345, 1984.
+
+
+ The function {distance_transform_edt} calculates the exact
+ euclidean distance transform of the input, by replacing each object
+ element (defined by values larger than zero) with the shortest
+ euclidean distance to the background (all non-object elements).
+
+ In addition to the distance transform, the feature transform can be
+ calculated. In this case the index of the closest background
+ element is returned along the first axis of the result. The
+ {return_distances}, and {return_indices} flags can be used to
+ indicate if the distance transform, the feature transform, or both
+ must be returned.
+
+ Optionally the sampling along each axis can be given by the
+ {sampling} parameter which should be a sequence of length equal to
+ the input rank, or a single number in which the sampling is assumed
+ to be equal along all axes.
+
+ The {distances} and {indices} arguments can be used to give
+ optional output arrays that must be of the correct size and type
+ ({Float64} and {Int32}).
+
+ The algorithm used to implement this function is described in: C.
+ R. Maurer, Jr., R. Qi, and V. Raghavan, "A linear time algorithm
+ for computing exact euclidean distance transforms of binary images
+ in arbitrary dimensions. IEEE Trans. PAMI 25, 265-270, 2003.
+
+
+ The function {distance_transform_bf} uses a brute-force algorithm
+ to calculate the distance transform of the input, by replacing each
+ object element (defined by values larger than zero) with the
+ shortest distance to the background (all non-object elements). The
+ metric must be one of {"euclidean"}, {"cityblock"}, or
+ {"chessboard"}.
+
+ In addition to the distance transform, the feature transform can be
+ calculated. In this case the index of the closest background
+ element is returned along the first axis of the result. The
+ {return_distances}, and {return_indices} flags can be used to
+ indicate if the distance transform, the feature transform, or both
+ must be returned.
+
+ Optionally the sampling along each axis can be given by the
+ {sampling} parameter which should be a sequence of length equal to
+ the input rank, or a single number in which the sampling is assumed
+ to be equal along all axes. This parameter is only used in the case
+ of the euclidean distance transform.
+
+ The {distances} and {indices} arguments can be used to give
+ optional output arrays that must be of the correct size and type
+ ({Float64} and {Int32}).
+
+ {This function uses a slow brute-force algorithm, the function
+ :func:`distance_transform_cdt` can be used to more efficiently
+ calculate cityblock and chessboard distance transforms. The function
+ :func:`distance_transform_edt` can be used to more efficiently
+ calculate the exact euclidean distance transform.}
+
+
+Segmentation and labeling
+=========================
+
+Segmentation is the process of separating objects of interest from
+the background. The most simple approach is probably intensity
+thresholding, which is easily done with {numarray} functions:
+
+::
+
+ >>> a = array([[1,2,2,1,1,0],
+ ... [0,2,3,1,2,0],
+ ... [1,1,1,3,3,2],
+ ... [1,1,1,1,2,1]])
+ >>> print where(a > 1, 1, 0)
+ [[0 1 1 0 0 0]
+ [0 1 1 0 1 0]
+ [0 0 0 1 1 1]
+ [0 0 0 0 1 0]]
+
+The result is a binary image, in which the individual objects still
+need to be identified and labeled. The function {label} generates
+an array where each object is assigned a unique number:
+
+ The {label} function generates an array where the objects in the
+ input are labeled with an integer index. It returns a tuple
+ consisting of the array of object labels and the number of objects
+ found, unless the {output} parameter is given, in which case only
+ the number of objects is returned. The connectivity of the objects
+ is defined by a structuring element. For instance, in two
+ dimensions using a four-connected structuring element gives:
+
+ ::
+
+ >>> a = array([[0,1,1,0,0,0],[0,1,1,0,1,0],[0,0,0,1,1,1],[0,0,0,0,1,0]])
+ >>> s = [[0, 1, 0], [1,1,1], [0,1,0]]
+ >>> print label(a, s)
+ (array([[0, 1, 1, 0, 0, 0],
+ [0, 1, 1, 0, 2, 0],
+ [0, 0, 0, 2, 2, 2],
+ [0, 0, 0, 0, 2, 0]]), 2)
+
+ These two objects are not connected because there is no way in
+ which we can place the structuring element such that it overlaps
+ with both objects. However, an 8-connected structuring element
+ results in only a single object:
+
+ ::
+
+ >>> a = array([[0,1,1,0,0,0],[0,1,1,0,1,0],[0,0,0,1,1,1],[0,0,0,0,1,0]])
+ >>> s = [[1,1,1], [1,1,1], [1,1,1]]
+ >>> print label(a, s)[0]
+ [[0 1 1 0 0 0]
+ [0 1 1 0 1 0]
+ [0 0 0 1 1 1]
+ [0 0 0 0 1 0]]
+
+ If no structuring element is provided, one is generated by calling
+ {generate_binary_structure} (see section :ref:`_ndimage_morphology`)
+ using a connectivity of one (which in 2D is the 4-connected
+ structure of the first example). The input can be of any type, any
+ value not equal to zero is taken to be part of an object. This is
+ useful if you need to 're-label' an array of object indices, for
+ instance after removing unwanted objects. Just apply the label
+ function again to the index array. For instance:
+
+ ::
+
+ >>> l, n = label([1, 0, 1, 0, 1])
+ >>> print l
+ [1 0 2 0 3]
+ >>> l = where(l != 2, l, 0)
+ >>> print l
+ [1 0 0 0 3]
+ >>> print label(l)[0]
+ [1 0 0 0 2]
+
+ {The structuring element used by :func:`label` is assumed to be
+ symmetric.}
+
+
+There is a large number of other approaches for segmentation, for
+instance from an estimation of the borders of the objects that can
+be obtained for instance by derivative filters. One such an
+approach is watershed segmentation. The function {watershed_ift}
+generates an array where each object is assigned a unique label,
+from an array that localizes the object borders, generated for
+instance by a gradient magnitude filter. It uses an array
+containing initial markers for the objects:
+
+ The {watershed_ift} function applies a watershed from markers
+ algorithm, using an Iterative Forest Transform, as described in: P.
+ Felkel, R. Wegenkittl, and M. Bruckschwaiger, "Implementation and
+ Complexity of the Watershed-from-Markers Algorithm Computed as a
+ Minimal Cost Forest.", Eurographics 2001, pp. C:26-35.
+
+ The inputs of this function are the array to which the transform is
+ applied, and an array of markers that designate the objects by a
+ unique label, where any non-zero value is a marker. For instance:
+
+ ::
+
+ >>> input = array([[0, 0, 0, 0, 0, 0, 0],
+ ... [0, 1, 1, 1, 1, 1, 0],
+ ... [0, 1, 0, 0, 0, 1, 0],
+ ... [0, 1, 0, 0, 0, 1, 0],
+ ... [0, 1, 0, 0, 0, 1, 0],
+ ... [0, 1, 1, 1, 1, 1, 0],
+ ... [0, 0, 0, 0, 0, 0, 0]], numarray.UInt8)
+ >>> markers = array([[1, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 2, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0]], numarray.Int8)
+ >>> print watershed_ift(input, markers)
+ [[1 1 1 1 1 1 1]
+ [1 1 2 2 2 1 1]
+ [1 2 2 2 2 2 1]
+ [1 2 2 2 2 2 1]
+ [1 2 2 2 2 2 1]
+ [1 1 2 2 2 1 1]
+ [1 1 1 1 1 1 1]]
+
+ Here two markers were used to designate an object (marker=2) and
+ the background (marker=1). The order in which these are processed
+ is arbitrary: moving the marker for the background to the lower
+ right corner of the array yields a different result:
+
+ ::
+
+ >>> markers = array([[0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 2, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 1]], numarray.Int8)
+ >>> print watershed_ift(input, markers)
+ [[1 1 1 1 1 1 1]
+ [1 1 1 1 1 1 1]
+ [1 1 2 2 2 1 1]
+ [1 1 2 2 2 1 1]
+ [1 1 2 2 2 1 1]
+ [1 1 1 1 1 1 1]
+ [1 1 1 1 1 1 1]]
+
+ The result is that the object (marker=2) is smaller because the
+ second marker was processed earlier. This may not be the desired
+ effect if the first marker was supposed to designate a background
+ object. Therefore {watershed_ift} treats markers with a negative
+ value explicitly as background markers and processes them after the
+ normal markers. For instance, replacing the first marker by a
+ negative marker gives a result similar to the first example:
+
+ ::
+
+ >>> markers = array([[0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 2, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, 0],
+ ... [0, 0, 0, 0, 0, 0, -1]], numarray.Int8)
+ >>> print watershed_ift(input, markers)
+ [[-1 -1 -1 -1 -1 -1 -1]
+ [-1 -1 2 2 2 -1 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 -1 2 2 2 -1 -1]
+ [-1 -1 -1 -1 -1 -1 -1]]
+
+ The connectivity of the objects is defined by a structuring
+ element. If no structuring element is provided, one is generated by
+ calling {generate_binary_structure} (see section
+ :ref:`_ndimage_morphology`) using a connectivity of one (which in 2D is
+ a 4-connected structure.) For example, using an 8-connected
+ structure with the last example yields a different object:
+
+ ::
+
+ >>> print watershed_ift(input, markers,
+ ... structure = [[1,1,1], [1,1,1], [1,1,1]])
+ [[-1 -1 -1 -1 -1 -1 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 2 2 2 2 2 -1]
+ [-1 -1 -1 -1 -1 -1 -1]]
+
+ {The implementation of :func:`watershed_ift` limits the data types
+ of the input to \\constant{UInt8} and \\constant{UInt16}.}
+
+
+Object measurements
+===================
+
+Given an array of labeled objects, the properties of the individual
+objects can be measured. The {find_objects} function can be used
+to generate a list of slices that for each object, give the
+smallest sub-array that fully contains the object:
+
+ The {find_objects} finds all objects in a labeled array and
+ returns a list of slices that correspond to the smallest regions in
+ the array that contains the object. For instance:
+
+ ::
+
+ >>> a = array([[0,1,1,0,0,0],[0,1,1,0,1,0],[0,0,0,1,1,1],[0,0,0,0,1,0]])
+ >>> l, n = label(a)
+ >>> f = find_objects(l)
+ >>> print a[f[0]]
+ [[1 1]
+ [1 1]]
+ >>> print a[f[1]]
+ [[0 1 0]
+ [1 1 1]
+ [0 1 0]]
+
+ {find_objects} returns slices for all objects, unless the
+ {max_label} parameter is larger then zero, in which case only the
+ first {max_label} objects are returned. If an index is missing in
+ the {label} array, {None} is return instead of a slice. For
+ example:
+
+ ::
+
+ >>> print find_objects([1, 0, 3, 4], max_label = 3)
+ [(slice(0, 1, None),), None, (slice(2, 3, None),)]
+
+
+The list of slices generated by {find_objects} is useful to find
+the position and dimensions of the objects in the array, but can
+also be used to perform measurements on the individual objects. Say
+we want to find the sum of the intensities of an object in image:
+
+::
+
+ >>> image = arange(4*6,shape=(4,6))
+ >>> mask = array([[0,1,1,0,0,0],[0,1,1,0,1,0],[0,0,0,1,1,1],[0,0,0,0,1,0]])
+ >>> labels = label(mask)[0]
+ >>> slices = find_objects(labels)
+
+Then we can calculate the sum of the elements in the second
+object:
+
+::
+
+ >>> print where(labels[slices[1]] == 2, image[slices[1]], 0).sum()
+ 80
+
+That is however not particularly efficient, and may also be more
+complicated for other types of measurements. Therefore a few
+measurements functions are defined that accept the array of object
+labels and the index of the object to be measured. For instance
+calculating the sum of the intensities can be done by:
+
+::
+
+ >>> print sum(image, labels, 2)
+ 80.0
+
+For large arrays and small objects it is more efficient to call the
+measurement functions after slicing the array:
+
+::
+
+ >>> print sum(image[slices[1]], labels[slices[1]], 2)
+ 80.0
+
+Alternatively, we can do the measurements for a number of labels
+with a single function call, returning a list of results. For
+instance, to measure the sum of the values of the background and
+the second object in our example we give a list of labels:
+
+::
+
+ >>> print sum(image, labels, [0, 2])
+ [178.0, 80.0]
+
+The measurement functions described below all support the {index}
+parameter to indicate which object(s) should be measured. The
+default value of {index} is {None}. This indicates that all
+elements where the label is larger than zero should be treated as a
+single object and measured. Thus, in this case the {labels} array
+is treated as a mask defined by the elements that are larger than
+zero. If {index} is a number or a sequence of numbers it gives the
+labels of the objects that are measured. If {index} is a sequence,
+a list of the results is returned. Functions that return more than
+one result, return their result as a tuple if {index} is a single
+number, or as a tuple of lists, if {index} is a sequence.
+
+ The {sum} function calculates the sum of the elements of the object
+ with label(s) given by {index}, using the {labels} array for the
+ object labels. If {index} is {None}, all elements with a non-zero
+ label value are treated as a single object. If {label} is {None},
+ all elements of {input} are used in the calculation.
+
+
+ The {mean} function calculates the mean of the elements of the
+ object with label(s) given by {index}, using the {labels} array for
+ the object labels. If {index} is {None}, all elements with a
+ non-zero label value are treated as a single object. If {label} is
+ {None}, all elements of {input} are used in the calculation.
+
+
+ The {variance} function calculates the variance of the elements of
+ the object with label(s) given by {index}, using the {labels} array
+ for the object labels. If {index} is {None}, all elements with a
+ non-zero label value are treated as a single object. If {label} is
+ {None}, all elements of {input} are used in the calculation.
+
+
+ The {standard_deviation} function calculates the standard
+ deviation of the elements of the object with label(s) given by
+ {index}, using the {labels} array for the object labels. If {index}
+ is {None}, all elements with a non-zero label value are treated as
+ a single object. If {label} is {None}, all elements of {input} are
+ used in the calculation.
+
+
+ The {minimum} function calculates the minimum of the elements of
+ the object with label(s) given by {index}, using the {labels} array
+ for the object labels. If {index} is {None}, all elements with a
+ non-zero label value are treated as a single object. If {label} is
+ {None}, all elements of {input} are used in the calculation.
+
+
+ The {maximum} function calculates the maximum of the elements of
+ the object with label(s) given by {index}, using the {labels} array
+ for the object labels. If {index} is {None}, all elements with a
+ non-zero label value are treated as a single object. If {label} is
+ {None}, all elements of {input} are used in the calculation.
+
+
+ The {minimum_position} function calculates the position of the
+ minimum of the elements of the object with label(s) given by
+ {index}, using the {labels} array for the object labels. If {index}
+ is {None}, all elements with a non-zero label value are treated as
+ a single object. If {label} is {None}, all elements of {input} are
+ used in the calculation.
+
+
+ The {maximum_position} function calculates the position of the
+ maximum of the elements of the object with label(s) given by
+ {index}, using the {labels} array for the object labels. If {index}
+ is {None}, all elements with a non-zero label value are treated as
+ a single object. If {label} is {None}, all elements of {input} are
+ used in the calculation.
+
+
+ The {extrema} function calculates the minimum, the maximum, and
+ their positions, of the elements of the object with label(s) given
+ by {index}, using the {labels} array for the object labels. If
+ {index} is {None}, all elements with a non-zero label value are
+ treated as a single object. If {label} is {None}, all elements of
+ {input} are used in the calculation. The result is a tuple giving
+ the minimum, the maximum, the position of the mininum and the
+ postition of the maximum. The result is the same as a tuple formed
+ by the results of the functions {minimum}, {maximum},
+ {minimum_position}, and {maximum_position} that are described
+ above.
+
+
+ The {center_of_mass} function calculates the center of mass of
+ the of the object with label(s) given by {index}, using the
+ {labels} array for the object labels. If {index} is {None}, all
+ elements with a non-zero label value are treated as a single
+ object. If {label} is {None}, all elements of {input} are used in
+ the calculation.
+
+
+ The {histogram} function calculates a histogram of the of the
+ object with label(s) given by {index}, using the {labels} array for
+ the object labels. If {index} is {None}, all elements with a
+ non-zero label value are treated as a single object. If {label} is
+ {None}, all elements of {input} are used in the calculation.
+ Histograms are defined by their minimum ({min}), maximum ({max})
+ and the number of bins ({bins}). They are returned as
+ one-dimensional arrays of type Int32.
+
+
+Extending {nd_image} in C
+============================
+
+.. _ndimage_ccallbacks:
+
+{C callback functions} A few functions in the {numarray.nd_image} take a call-back argument. This can be a python function, but also a CObject containing a pointer to a C function. To use this feature, you must write your own C extension that defines the function, and define a python function that
+returns a CObject containing a pointer to this function.
+
+An example of a function that supports this is
+{geometric_transform} (see section :ref:`_ndimage_interpolation`).
+You can pass it a python callable object that defines a mapping
+from all output coordinates to corresponding coordinates in the
+input array. This mapping function can also be a C function, which
+generally will be much more efficient, since the overhead of
+calling a python function at each element is avoided.
+
+For example to implement a simple shift function we define the
+following function:
+
+::
+
+ static int
+ _shift_function(int *output_coordinates, double* input_coordinates,
+ int output_rank, int input_rank, void *callback_data)
+ {
+ int ii;
+ /* get the shift from the callback data pointer: */
+ double shift = *(double*)callback_data;
+ /* calculate the coordinates: */
+ for(ii = 0; ii < irank; ii++)
+ icoor[ii] = ocoor[ii] - shift;
+ /* return OK status: */
+ return 1;
+ }
+
+This function is called at every element of the output array,
+passing the current coordinates in the {output_coordinates} array.
+On return, the {input_coordinates} array must contain the
+coordinates at which the input is interpolated. The ranks of the
+input and output array are passed through {output_rank} and
+{input_rank}. The value of the shift is passed through the
+{callback_data} argument, which is a pointer to void. The function
+returns an error status, in this case always 1, since no error can
+occur.
+
+A pointer to this function and a pointer to the shift value must be
+passed to {geometric_transform}. Both are passed by a single
+CObject which is created by the following python extension
+function:
+
+::
+
+ static PyObject *
+ py_shift_function(PyObject *obj, PyObject *args)
+ {
+ double shift = 0.0;
+ if (!PyArg_ParseTuple(args, "d", &shift)) {
+ PyErr_SetString(PyExc_RuntimeError, "invalid parameters");
+ return NULL;
+ } else {
+ /* assign the shift to a dynamically allocated location: */
+ double *cdata = (double*)malloc(sizeof(double));
+ *cdata = shift;
+ /* wrap function and callback_data in a CObject: */
+ return PyCObject_FromVoidPtrAndDesc(_shift_function, cdata,
+ _destructor);
+ }
+ }
+
+The value of the shift is obtained and then assigned to a
+dynamically allocated memory location. Both this data pointer and
+the function pointer are then wrapped in a CObject, which is
+returned. Additionally, a pointer to a destructor function is
+given, that will free the memory we allocated for the shift value
+when the CObject is destroyed. This destructor is very simple:
+
+::
+
+ static void
+ _destructor(void* cobject, void *cdata)
+ {
+ if (cdata)
+ free(cdata);
+ }
+
+To use these functions, an extension module is build:
+
+::
+
+ static PyMethodDef methods[] = {
+ {"shift_function", (PyCFunction)py_shift_function, METH_VARARGS, ""},
+ {NULL, NULL, 0, NULL}
+ };
+
+ void
+ initexample(void)
+ {
+ Py_InitModule("example", methods);
+ }
+
+This extension can then be used in Python, for example:
+
+::
+
+ >>> import example
+ >>> array = arange(12, shape=(4,3), type = Float64)
+ >>> fnc = example.shift_function(0.5)
+ >>> print geometric_transform(array, fnc)
+ [[ 0. 0. 0. ]
+ [ 0. 1.3625 2.7375]
+ [ 0. 4.8125 6.1875]
+ [ 0. 8.2625 9.6375]]
+
+C Callback functions for use with {nd_image} functions must all
+be written according to this scheme. The next section lists the
+{nd_image} functions that acccept a C callback function and
+gives the prototype of the callback function.
+
+Functions that support C callback functions
+-------------------------------------------
+
+The {nd_image} functions that support C callback functions are
+described here. Obviously, the prototype of the function that is
+provided to these functions must match exactly that what they
+expect. Therefore we give here the prototypes of the callback
+functions. All these callback functions accept a void
+{callback_data} pointer that must be wrapped in a CObject using
+the Python {PyCObject_FromVoidPtrAndDesc} function, which can also
+accept a pointer to a destructor function to free any memory
+allocated for {callback_data}. If {callback_data} is not needed,
+{PyCObject_FromVoidPtr} may be used instead. The callback
+functions must return an integer error status that is equal to zero
+if something went wrong, or 1 otherwise. If an error occurs, you
+should normally set the python error status with an informative
+message before returning, otherwise, a default error message is set
+by the calling function.
+
+The function {generic_filter} (see section
+:ref:`_ndimage_genericfilters`) accepts a callback function with the
+following prototype:
+
+ The calling function iterates over the elements of the input and
+ output arrays, calling the callback function at each element. The
+ elements within the footprint of the filter at the current element
+ are passed through the {buffer} parameter, and the number of
+ elements within the footprint through {filter_size}. The
+ calculated valued should be returned in the {return_value}
+ argument.
+
+
+The function {generic_filter1d} (see section
+:ref:`_ndimage_genericfilters`) accepts a callback function with the
+following prototype:
+
+ The calling function iterates over the lines of the input and
+ output arrays, calling the callback function at each line. The
+ current line is extended according to the border conditions set by
+ the calling function, and the result is copied into the array that
+ is passed through the {input_line} array. The length of the input
+ line (after extension) is passed through {input_length}. The
+ callback function should apply the 1D filter and store the result
+ in the array passed through {output_line}. The length of the
+ output line is passed through {output_length}.
+
+
+The function {geometric_transform} (see section
+:ref:`_ndimage_interpolation`) expects a function with the following
+prototype:
+
+ The calling function iterates over the elements of the output
+ array, calling the callback function at each element. The
+ coordinates of the current output element are passed through
+ {output_coordinates}. The callback function must return the
+ coordinates at which the input must be interpolated in
+ {input_coordinates}. The rank of the input and output arrays are
+ given by {input_rank} and {output_rank} respectively.
+
+
+
From scipy-svn at scipy.org Fri Dec 19 12:55:51 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Fri, 19 Dec 2008 11:55:51 -0600 (CST)
Subject: [Scipy-svn] r5278 - in trunk/doc: . frontpage/_templates
Message-ID: <20081219175551.D12DFC8410A@scipy.org>
Author: ptvirtan
Date: 2008-12-19 11:55:32 -0600 (Fri, 19 Dec 2008)
New Revision: 5278
Modified:
trunk/doc/Makefile
trunk/doc/frontpage/_templates/indexcontent.html
Log:
docs: put CHM files in a zip, to work around http://support.microsoft.com/kb/902225/
Modified: trunk/doc/Makefile
===================================================================
--- trunk/doc/Makefile 2008-12-18 23:49:30 UTC (rev 5277)
+++ trunk/doc/Makefile 2008-12-19 17:55:32 UTC (rev 5278)
@@ -44,7 +44,7 @@
perl -pi -e 's#^\s*(SciPy.*?Reference Guide.*?»)\s*$$#Numpy and Scipy Documentation » $$1#;' build/dist/*.html build/dist/*/*.html build/dist/*/*/*.html
(cd build/html && zip -9qr ../dist/scipy-html.zip .)
cp build/latex/scipy*.pdf build/dist
- -cp build/htmlhelp/scipy.chm build/dist
+ -zip build/dist/scipy-chm.zip build/htmlhelp/scipy.chm
cd build/dist && tar czf ../dist.tar.gz *
chmod ug=rwX,o=rX -R build/dist
find build/dist -type d -print0 | xargs -0r chmod g+s
Modified: trunk/doc/frontpage/_templates/indexcontent.html
===================================================================
--- trunk/doc/frontpage/_templates/indexcontent.html 2008-12-18 23:49:30 UTC (rev 5277)
+++ trunk/doc/frontpage/_templates/indexcontent.html 2008-12-19 17:55:32 UTC (rev 5278)
@@ -19,7 +19,7 @@
|
Numpy Reference Guide
[HTML+zip],
- [HTML-help (CHM)],
+ [HTML-help (CHM)],
[PDF]
Numpy User Guide
@@ -27,7 +27,7 @@
Scipy Reference Guide
[HTML+zip],
- [HTML-help (CHM)],
+ [HTML-help (CHM)],
[PDF]
|
From scipy-svn at scipy.org Fri Dec 19 15:34:05 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Fri, 19 Dec 2008 14:34:05 -0600 (CST)
Subject: [Scipy-svn] r5279 - in trunk/scipy/signal: . tests
Message-ID: <20081219203405.4F032C7C023@scipy.org>
Author: jarrod.millman
Date: 2008-12-19 14:34:02 -0600 (Fri, 19 Dec 2008)
New Revision: 5279
Modified:
trunk/scipy/signal/medianfilter.c
trunk/scipy/signal/tests/test_signaltools.py
Log:
Applying patch from Ray Jones to medianfilter to remove code based
on Numerical Recipes. It includes the following:
* new quickselect (from scratch) in medianfilter.c
* new macros for {f,d,b}_medfilt2 in medianfilter.c
* modified test for medfilt and medfilt2 (larger array, non-square filter).
Modified: trunk/scipy/signal/medianfilter.c
===================================================================
--- trunk/scipy/signal/medianfilter.c 2008-12-19 17:55:32 UTC (rev 5278)
+++ trunk/scipy/signal/medianfilter.c 2008-12-19 20:34:02 UTC (rev 5279)
@@ -1,311 +1,127 @@
/*--------------------------------------------------------------------*/
-/*
- * This Quickselect routine is based on the algorithm described in
- * "Numerical recipies in C", Second Edition,
- * Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5
- */
-
#include "Python.h"
#define NO_IMPORT_ARRAY
#include "numpy/noprefix.h"
+
+/* defined below */
void f_medfilt2(float*,float*,intp*,intp*);
void d_medfilt2(double*,double*,intp*,intp*);
void b_medfilt2(unsigned char*,unsigned char*,intp*,intp*);
extern char *check_malloc (int);
-#define ELEM_SWAP(a,b) { register float t=(a);(a)=(b);(b)=t; }
-float f_quick_select(float arr[], int n)
-{
- int low, high ;
- int median;
- int middle, ll, hh;
+/* The QUICK_SELECT routine is based on Hoare's Quickselect algorithm,
+ * with unrolled recursion.
+ * Author: Thouis R. Jones, 2008
+ */
- low = 0 ; high = n-1 ; median = (low + high) / 2;
- for (;;) {
- if (high <= low) /* One element only */
- return arr[median] ;
+#define ELEM_SWAP(t, a, x, y) {register t temp = (a)[x]; (a)[x] = (a)[y]; (a)[y] = temp;}
+#define FIRST_LOWEST(x, y, z) (((x) < (y)) && ((x) < (z)))
+#define FIRST_HIGHEST(x, y, z) (((x) > (y)) && ((x) > (z)))
+#define LOWEST_IDX(a, x, y) (((a)[x] < (a)[y]) ? (x) : (y))
+#define HIGHEST_IDX(a, x, y) (((a)[x] > (a)[y]) ? (x) : (y))
- if (high == low + 1) { /* Two elements only */
- if (arr[low] > arr[high])
- ELEM_SWAP(arr[low], arr[high]) ;
- return arr[median] ;
- }
+/* if (l is index of lowest) {return lower of mid,hi} else if (l is index of highest) {return higher of mid,hi} else return l */
+#define MEDIAN_IDX(a, l, m, h) (FIRST_LOWEST((a)[l], (a)[m], (a)[h]) ? LOWEST_IDX(a, m, h) : (FIRST_HIGHEST((a)[l], (a)[m], (a)[h]) ? HIGHEST_IDX(a, m, h) : (l)))
- /* Find median of low, middle and high items; swap into position low */
- middle = (low + high) / 2;
- if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
- if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
- if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
-
- /* Swap low item (now in position middle) into position (low+1) */
- ELEM_SWAP(arr[middle], arr[low+1]) ;
-
- /* Nibble from each end towards middle, swapping items when stuck */
- ll = low + 1;
- hh = high;
- for (;;) {
- do ll++; while (arr[low] > arr[ll]) ;
- do hh--; while (arr[hh] > arr[low]) ;
-
- if (hh < ll)
- break;
-
- ELEM_SWAP(arr[ll], arr[hh]) ;
- }
-
- /* Swap middle item (in position low) back into correct position */
- ELEM_SWAP(arr[low], arr[hh]) ;
-
- /* Re-set active partition */
- if (hh <= median)
- low = ll;
- if (hh >= median)
- high = hh - 1;
- }
+#define QUICK_SELECT(NAME, TYPE) \
+TYPE NAME(TYPE arr[], int n) \
+{ \
+ int lo, hi, mid, md; \
+ int median_idx; \
+ int ll, hh; \
+ TYPE piv; \
+ \
+ lo = 0; hi = n-1; \
+ median_idx = (n - 1) / 2; /* lower of middle values for even-length arrays */ \
+ \
+ while (1) { \
+ if ((hi - lo) < 2) { \
+ if (arr[hi] < arr[lo]) ELEM_SWAP(TYPE, arr, lo, hi); \
+ return arr[median_idx]; \
+ } \
+ \
+ mid = (hi + lo) / 2; \
+ /* put the median of lo,mid,hi at position lo - this will be the pivot */ \
+ md = MEDIAN_IDX(arr, lo, mid, hi); \
+ ELEM_SWAP(TYPE, arr, lo, md); \
+ \
+ /* Nibble from each end towards middle, swapping misordered items */ \
+ piv = arr[lo]; \
+ for (ll = lo+1, hh = hi;; ll++, hh--) { \
+ while (arr[ll] < piv) ll++; \
+ while (arr[hh] > piv) hh--; \
+ if (hh < ll) break; \
+ ELEM_SWAP(TYPE, arr, ll, hh); \
+ } \
+ /* move pivot to top of lower partition */ \
+ ELEM_SWAP(TYPE, arr, hh, lo); \
+ /* set lo, hi for new range to search */ \
+ if (hh < median_idx) /* search upper partition */ \
+ lo = hh+1; \
+ else if (hh > median_idx) /* search lower partition */ \
+ hi = hh-1; \
+ else \
+ return piv; \
+ } \
}
-#undef ELEM_SWAP
-
-#define ELEM_SWAP(a,b) { register double t=(a);(a)=(b);(b)=t; }
-
-double d_quick_select(double arr[], int n)
-{
- int low, high ;
- int median;
- int middle, ll, hh;
-
- low = 0 ; high = n-1 ; median = (low + high) / 2;
- for (;;) {
- if (high <= low) /* One element only */
- return arr[median] ;
-
- if (high == low + 1) { /* Two elements only */
- if (arr[low] > arr[high])
- ELEM_SWAP(arr[low], arr[high]) ;
- return arr[median] ;
- }
-
- /* Find median of low, middle and high items; swap into position low */
- middle = (low + high) / 2;
- if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
- if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
- if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
-
- /* Swap low item (now in position middle) into position (low+1) */
- ELEM_SWAP(arr[middle], arr[low+1]) ;
-
- /* Nibble from each end towards middle, swapping items when stuck */
- ll = low + 1;
- hh = high;
- for (;;) {
- do ll++; while (arr[low] > arr[ll]) ;
- do hh--; while (arr[hh] > arr[low]) ;
-
- if (hh < ll)
- break;
-
- ELEM_SWAP(arr[ll], arr[hh]) ;
- }
-
- /* Swap middle item (in position low) back into correct position */
- ELEM_SWAP(arr[low], arr[hh]) ;
-
- /* Re-set active partition */
- if (hh <= median)
- low = ll;
- if (hh >= median)
- high = hh - 1;
- }
-}
-
-#undef ELEM_SWAP
-
-#define ELEM_SWAP(a,b) { register unsigned char t=(a);(a)=(b);(b)=t; }
-
-unsigned char b_quick_select(unsigned char arr[], int n)
-{
- int low, high ;
- int median;
- int middle, ll, hh;
-
- low = 0 ; high = n-1 ; median = (low + high) / 2;
- for (;;) {
- if (high <= low) /* One element only */
- return arr[median] ;
-
- if (high == low + 1) { /* Two elements only */
- if (arr[low] > arr[high])
- ELEM_SWAP(arr[low], arr[high]) ;
- return arr[median] ;
- }
-
- /* Find median of low, middle and high items; swap into position low */
- middle = (low + high) / 2;
- if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
- if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
- if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
-
- /* Swap low item (now in position middle) into position (low+1) */
- ELEM_SWAP(arr[middle], arr[low+1]) ;
-
- /* Nibble from each end towards middle, swapping items when stuck */
- ll = low + 1;
- hh = high;
- for (;;) {
- do ll++; while (arr[low] > arr[ll]) ;
- do hh--; while (arr[hh] > arr[low]) ;
-
- if (hh < ll)
- break;
-
- ELEM_SWAP(arr[ll], arr[hh]) ;
- }
-
- /* Swap middle item (in position low) back into correct position */
- ELEM_SWAP(arr[low], arr[hh]) ;
-
- /* Re-set active partition */
- if (hh <= median)
- low = ll;
- if (hh >= median)
- high = hh - 1;
- }
-}
-
-#undef ELEM_SWAP
-
/* 2-D median filter with zero-padding on edges. */
-void d_medfilt2(double* in, double* out, intp* Nwin, intp* Ns)
-{
- int nx, ny, hN[2];
- int pre_x, pre_y, pos_x, pos_y;
- int subx, suby, k, totN;
- double *myvals, *fptr1, *fptr2, *ptr1, *ptr2;
-
- totN = Nwin[0] * Nwin[1];
- myvals = (double *) check_malloc( totN * sizeof(double));
-
- hN[0] = Nwin[0] >> 1;
- hN[1] = Nwin[1] >> 1;
- ptr1 = in;
- fptr1 = out;
- for (ny = 0; ny < Ns[0]; ny++)
- for (nx = 0; nx < Ns[1]; nx++) {
- pre_x = hN[1];
- pre_y = hN[0];
- pos_x = hN[1];
- pos_y = hN[0];
- if (nx < hN[1]) pre_x = nx;
- if (nx >= Ns[1] - hN[1]) pos_x = Ns[1] - nx - 1;
- if (ny < hN[0]) pre_y = ny;
- if (ny >= Ns[0] - hN[0]) pos_y = Ns[0] - ny - 1;
- fptr2 = myvals;
- ptr2 = ptr1 - pre_x - pre_y*Ns[1];
- for (suby = -pre_y; suby <= pos_y; suby++) {
- for (subx = -pre_x; subx <= pos_x; subx++)
- *fptr2++ = *ptr2++;
- ptr2 += Ns[1] - (pre_x + pos_x + 1);
- }
- ptr1++;
-
- /* Zero pad */
- for (k = (pre_x + pos_x + 1)*(pre_y + pos_y + 1); k < totN; k++)
- *fptr2++ = 0.0;
-
- /* *fptr1++ = median(myvals,totN); */
- *fptr1++ = d_quick_select(myvals,totN);
- }
+#define MEDIAN_FILTER_2D(NAME, TYPE, SELECT) \
+void NAME(TYPE* in, TYPE* out, intp* Nwin, intp* Ns) \
+{ \
+ int nx, ny, hN[2]; \
+ int pre_x, pre_y, pos_x, pos_y; \
+ int subx, suby, k, totN; \
+ TYPE *myvals, *fptr1, *fptr2, *ptr1, *ptr2; \
+ \
+ totN = Nwin[0] * Nwin[1]; \
+ myvals = (TYPE *) check_malloc( totN * sizeof(TYPE)); \
+ \
+ hN[0] = Nwin[0] >> 1; \
+ hN[1] = Nwin[1] >> 1; \
+ ptr1 = in; \
+ fptr1 = out; \
+ for (ny = 0; ny < Ns[0]; ny++) \
+ for (nx = 0; nx < Ns[1]; nx++) { \
+ pre_x = hN[1]; \
+ pre_y = hN[0]; \
+ pos_x = hN[1]; \
+ pos_y = hN[0]; \
+ if (nx < hN[1]) pre_x = nx; \
+ if (nx >= Ns[1] - hN[1]) pos_x = Ns[1] - nx - 1; \
+ if (ny < hN[0]) pre_y = ny; \
+ if (ny >= Ns[0] - hN[0]) pos_y = Ns[0] - ny - 1; \
+ fptr2 = myvals; \
+ ptr2 = ptr1 - pre_x - pre_y*Ns[1]; \
+ for (suby = -pre_y; suby <= pos_y; suby++) { \
+ for (subx = -pre_x; subx <= pos_x; subx++) \
+ *fptr2++ = *ptr2++; \
+ ptr2 += Ns[1] - (pre_x + pos_x + 1); \
+ } \
+ ptr1++; \
+ \
+ /* Zero pad */ \
+ for (k = (pre_x + pos_x + 1)*(pre_y + pos_y + 1); k < totN; k++) \
+ *fptr2++ = 0.0; \
+ \
+ /* *fptr1++ = median(myvals,totN); */ \
+ *fptr1++ = SELECT(myvals,totN); \
+ } \
+ free(myvals); \
}
-/* 2-D median filter with zero-padding on edges. */
-void f_medfilt2(float* in, float* out, intp* Nwin, intp* Ns)
-{
- int nx, ny, hN[2];
- int pre_x, pre_y, pos_x, pos_y;
- int subx, suby, k, totN;
- float *myvals, *fptr1, *fptr2, *ptr1, *ptr2;
+/* define quick_select for floats, doubles, and unsigned characters */
+QUICK_SELECT(f_quick_select, float)
+QUICK_SELECT(d_quick_select, double)
+QUICK_SELECT(b_quick_select, unsigned char)
- totN = Nwin[0] * Nwin[1];
- myvals = (float *) check_malloc( totN * sizeof(float));
-
- hN[0] = Nwin[0] >> 1;
- hN[1] = Nwin[1] >> 1;
- ptr1 = in;
- fptr1 = out;
- for (ny = 0; ny < Ns[0]; ny++)
- for (nx = 0; nx < Ns[1]; nx++) {
- pre_x = hN[1];
- pre_y = hN[0];
- pos_x = hN[1];
- pos_y = hN[0];
- if (nx < hN[1]) pre_x = nx;
- if (nx >= Ns[1] - hN[1]) pos_x = Ns[1] - nx - 1;
- if (ny < hN[0]) pre_y = ny;
- if (ny >= Ns[0] - hN[0]) pos_y = Ns[0] - ny - 1;
- fptr2 = myvals;
- ptr2 = ptr1 - pre_x - pre_y*Ns[1];
- for (suby = -pre_y; suby <= pos_y; suby++) {
- for (subx = -pre_x; subx <= pos_x; subx++)
- *fptr2++ = *ptr2++;
- ptr2 += Ns[1] - (pre_x + pos_x + 1);
- }
- ptr1++;
-
- /* Zero pad */
- for (k = (pre_x + pos_x + 1)*(pre_y + pos_y + 1); k < totN; k++)
- *fptr2++ = 0.0;
-
- /* *fptr1++ = median(myvals,totN); */
- *fptr1++ = f_quick_select(myvals,totN);
- }
-}
-
-
-/* 2-D median filter with zero-padding on edges. */
-void b_medfilt2(unsigned char *in, unsigned char *out, intp* Nwin, intp* Ns)
-{
- int nx, ny, hN[2];
- int pre_x, pre_y, pos_x, pos_y;
- int subx, suby, k, totN;
- unsigned char *myvals, *fptr1, *fptr2, *ptr1, *ptr2;
-
- totN = Nwin[0] * Nwin[1];
- myvals = (unsigned char *) check_malloc( totN * sizeof(unsigned char));
-
- hN[0] = Nwin[0] >> 1;
- hN[1] = Nwin[1] >> 1;
- ptr1 = in;
- fptr1 = out;
- for (ny = 0; ny < Ns[0]; ny++)
- for (nx = 0; nx < Ns[1]; nx++) {
- pre_x = hN[1];
- pre_y = hN[0];
- pos_x = hN[1];
- pos_y = hN[0];
- if (nx < hN[1]) pre_x = nx;
- if (nx >= Ns[1] - hN[1]) pos_x = Ns[1] - nx - 1;
- if (ny < hN[0]) pre_y = ny;
- if (ny >= Ns[0] - hN[0]) pos_y = Ns[0] - ny - 1;
- fptr2 = myvals;
- ptr2 = ptr1 - pre_x - pre_y*Ns[1];
- for (suby = -pre_y; suby <= pos_y; suby++) {
- for (subx = -pre_x; subx <= pos_x; subx++)
- *fptr2++ = *ptr2++;
- ptr2 += Ns[1] - (pre_x + pos_x + 1);
- }
- ptr1++;
-
- /* Zero pad */
- for (k = (pre_x + pos_x + 1)*(pre_y + pos_y + 1); k < totN; k++)
- *fptr2++ = 0.0;
-
- /* *fptr1++ = median(myvals,totN); */
- *fptr1++ = b_quick_select(myvals,totN);
- }
-}
+/* define medfilt for floats, doubles, and unsigned characters */
+MEDIAN_FILTER_2D(f_medfilt2, float, f_quick_select)
+MEDIAN_FILTER_2D(d_medfilt2, double, d_quick_select)
+MEDIAN_FILTER_2D(b_medfilt2, unsigned char, b_quick_select)
Modified: trunk/scipy/signal/tests/test_signaltools.py
===================================================================
--- trunk/scipy/signal/tests/test_signaltools.py 2008-12-19 17:55:32 UTC (rev 5278)
+++ trunk/scipy/signal/tests/test_signaltools.py 2008-12-19 20:34:02 UTC (rev 5279)
@@ -28,9 +28,30 @@
class TestMedFilt(TestCase):
def test_basic(self):
- f = [[3,4,5],[2,3,4],[1,2,5]]
- d = signal.medfilt(f)
- assert_array_equal(d, [[0,3,0],[2,3,3],[0,2,0]])
+ f = [[50, 50, 50, 50, 50, 92, 18, 27, 65, 46],
+ [50, 50, 50, 50, 50, 0, 72, 77, 68, 66],
+ [50, 50, 50, 50, 50, 46, 47, 19, 64, 77],
+ [50, 50, 50, 50, 50, 42, 15, 29, 95, 35],
+ [50, 50, 50, 50, 50, 46, 34, 9, 21, 66],
+ [70, 97, 28, 68, 78, 77, 61, 58, 71, 42],
+ [64, 53, 44, 29, 68, 32, 19, 68, 24, 84],
+ [ 3, 33, 53, 67, 1, 78, 74, 55, 12, 83],
+ [ 7, 11, 46, 70, 60, 47, 24, 43, 61, 26],
+ [32, 61, 88, 7, 39, 4, 92, 64, 45, 61]]
+
+ d = signal.medfilt(f, [7, 3])
+ e = signal.medfilt2d(np.array(f, np.float), [7, 3])
+ assert_array_equal(d, [[ 0, 50, 50, 50, 42, 15, 15, 18, 27, 0],
+ [ 0, 50, 50, 50, 50, 42, 19, 21, 29, 0],
+ [50, 50, 50, 50, 50, 47, 34, 34, 46, 35],
+ [50, 50, 50, 50, 50, 50, 42, 47, 64, 42],
+ [50, 50, 50, 50, 50, 50, 46, 55, 64, 35],
+ [33, 50, 50, 50, 50, 47, 46, 43, 55, 26],
+ [32, 50, 50, 50, 50, 47, 46, 45, 55, 26],
+ [ 7, 46, 50, 50, 47, 46, 46, 43, 45, 21],
+ [ 0, 32, 33, 39, 32, 32, 43, 43, 43, 0],
+ [ 0, 7, 11, 7, 4, 4, 19, 19, 24, 0]])
+ assert_array_equal(d, e)
class TestWiener(TestCase):
def test_basic(self):
From scipy-svn at scipy.org Sat Dec 20 01:53:25 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 20 Dec 2008 00:53:25 -0600 (CST)
Subject: [Scipy-svn] r5280 - in trunk/scipy/stats: . tests
Message-ID: <20081220065325.74655C7C043@scipy.org>
Author: josef
Date: 2008-12-20 00:53:22 -0600 (Sat, 20 Dec 2008)
New Revision: 5280
Modified:
trunk/scipy/stats/stats.py
trunk/scipy/stats/tests/test_stats.py
Log:
ttest_rel: some cleanup, rewrite main formula
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-19 20:34:02 UTC (rev 5279)
+++ trunk/scipy/stats/stats.py 2008-12-20 06:53:22 UTC (rev 5280)
@@ -1950,7 +1950,6 @@
zerodivproblem = svar == 0
t = (x1-x2)/np.sqrt(svar*(1.0/n1 + 1.0/n2)) # N-D COMPUTATION HERE!!!!!!
t = np.where(zerodivproblem, 1.0, t) # replace NaN t-values with 1.0
- #probs = betai(0.5*df,0.5,float(df)/(df+t*t))
probs = distributions.t.sf(np.abs(t),df)*2
if not np.isscalar(t):
@@ -2017,13 +2016,11 @@
df = float(n-1)
d = (a-b).astype('d')
- #denom is just var(d)/df
- denom = np.sqrt((n*np.add.reduce(d*d,axis) - np.add.reduce(d,axis)**2) /df)
+ #denom is just sqrt(var(d)/df)
+ denom = np.sqrt(np.var(d,axis,ddof=1)/float(n))
zerodivproblem = denom == 0
- t = np.add.reduce(d, axis) / denom # N-D COMPUTATION HERE!!!!!!
+ t = np.mean(d, axis) / denom
t = np.where(zerodivproblem, 1.0, t) # replace NaN t-values with 1.0
- t = np.where(zerodivproblem, 1.0, t) # replace NaN t-values with 1.0
- #probs = betai(0.5*df,0.5,float(df)/(df+t*t))
probs = distributions.t.sf(np.abs(t),df)*2
if not np.isscalar(t):
probs = np.reshape(probs, t.shape)
Modified: trunk/scipy/stats/tests/test_stats.py
===================================================================
--- trunk/scipy/stats/tests/test_stats.py 2008-12-19 20:34:02 UTC (rev 5279)
+++ trunk/scipy/stats/tests/test_stats.py 2008-12-20 06:53:22 UTC (rev 5280)
@@ -1054,5 +1054,24 @@
np.linspace(1,100,110)+20-0.1)),
np.array((0.20818181818181825, 0.017981441789762638)))
+def test_ttest_rel():
+ #regression test
+ tr,pr = 0.81248591389165692, 0.41846234511362157
+ tpr = ([tr,-tr],[pr,pr])
+
+ rvs1 = np.linspace(1,100,100)
+ rvs2 = np.linspace(1.01,99.989,100)
+ rvs1_2D = np.array([np.linspace(1,100,100), np.linspace(1.01,99.989,100)])
+ rvs2_2D = np.array([np.linspace(1.01,99.989,100), np.linspace(1,100,100)])
+
+ t,p = stats.ttest_rel(rvs1, rvs2, axis=0)
+ assert_array_almost_equal([t,p],(tr,pr))
+ t,p = stats.ttest_rel(rvs1_2D.T, rvs2_2D.T, axis=0)
+ assert_array_almost_equal([t,p],tpr)
+ t,p = stats.ttest_rel(rvs1_2D, rvs2_2D, axis=1)
+ assert_array_almost_equal([t,p],tpr)
+
+
+
if __name__ == "__main__":
run_module_suite()
From scipy-svn at scipy.org Sat Dec 20 06:05:18 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 20 Dec 2008 05:05:18 -0600 (CST)
Subject: [Scipy-svn] r5281 - trunk/doc/source/tutorial
Message-ID: <20081220110518.0487AC7C042@scipy.org>
Author: david.warde-farley
Date: 2008-12-20 05:05:15 -0600 (Sat, 20 Dec 2008)
New Revision: 5281
Modified:
trunk/doc/source/tutorial/ndimage.rst
Log:
Huge fixer-upper. All module functions prefixed with :func: (is this correct?). All parameters enclosed in \*param\* (seemed like the closest thing in the Sphinx documentation that I could find. Tables and sectional cross-references fixed.
Modified: trunk/doc/source/tutorial/ndimage.rst
===================================================================
--- trunk/doc/source/tutorial/ndimage.rst 2008-12-20 06:53:22 UTC (rev 5280)
+++ trunk/doc/source/tutorial/ndimage.rst 2008-12-20 11:05:15 UTC (rev 5281)
@@ -1,42 +1,44 @@
-Multi-dimensional image processing
-==================================
+Multi-dimensional image processing (:mod:`ndimage`)
+=========================================================
-{Peter Verveer} {verveer at users.sourceforge.net}
-{Multidimensional image analysis functions}
+.. moduleauthor:: Peter Verveer
-.. _ndimage_introduction:
+.. currentmodule:: scipy.ndimage
+
+.. _ndimage-introduction:
+
Introduction
-============
+------------
Image processing and analysis are generally seen as operations on
two-dimensional arrays of values. There are however a number of
fields where images of higher dimensionality must be analyzed. Good
examples of these are medical imaging and biological imaging.
-{numarray} is suited very well for this type of applications due
-its inherent multi-dimensional nature. The {numarray.nd_image}
+:mod:`numarray` is suited very well for this type of applications due
+its inherent multi-dimensional nature. The :mod:`scipy.ndimage`
packages provides a number of general image processing and analysis
functions that are designed to operate with arrays of arbitrary
dimensionality. The packages currently includes functions for
linear and non-linear filtering, binary morphology, B-spline
interpolation, and object measurements.
-.. _ndimage_properties_shared_by_all_functions:
+.. _ndimage-properties-shared-by-all-functions:
Properties shared by all functions
-==================================
+----------------------------------
All functions share some common properties. Notably, all functions
-allow the specification of an output array with the {output}
+allow the specification of an output array with the *output*
argument. With this argument you can specify an array that will be
changed in-place with the result with the operation. In this case
-the result is not returned. Usually, using the {output} argument is
+the result is not returned. Usually, using the *output* argument is
more efficient, since an existing array is used to store the
result.
The type of arrays returned is dependent on the type of operation,
but it is in most cases equal to the type of the input. If,
-however, the {output} argument is used, the type of the result is
+however, the *output* argument is used, the type of the result is
equal to the type of the specified output argument. If no output
argument is given, it is still possible to specify what the result
of the output should be. This is done by simply assigning the
@@ -51,15 +53,15 @@
{In previous versions of :mod:`scipy.ndimage`, some functions accepted the *output_type* argument to achieve the same effect. This argument is still supported, but its use will generate an deprecation warning. In a future version all instances of this argument will be removed. The preferred way to specify an output type, is by using the *output* argument, either by specifying an output array of the desired type, or by specifying the type of the output that is to be returned.}
+.. _ndimage-filter-functions:
+
Filter functions
-================
+----------------
-.. _ndimage_filter_functions:
-
The functions described in this section all perform some type of spatial filtering of the the input array: the elements in the output are some function of the values in the neighborhood of the corresponding input element. We refer to this neighborhood of elements as the filter kernel, which is often
rectangular in shape but may also have an arbitrary footprint. Many
of the functions described below allow you to define the footprint
-of the kernel, by passing a mask through the {footprint} parameter.
+of the kernel, by passing a mask through the *footprint* parameter.
For example a cross shaped kernel can be defined as follows:
::
@@ -84,7 +86,7 @@
[0 0 1 1 1 0 0]
Sometimes it is convenient to choose a different origin for the
-kernel. For this reason most functions support the {origin}
+kernel. For this reason most functions support the *origin*
parameter which gives the origin of the filter relative to its
center. For example:
@@ -115,7 +117,7 @@
[ 0 1 0 0 -1 0 0]
however, using the origin parameter instead of a larger kernel is
-more efficient. For multi-dimensional kernels {origin} can be a
+more efficient. For multi-dimensional kernels *origin* can be a
number, in which case the origin is assumed to be equal along all
axes, or a sequence giving the origin along each axis.
@@ -125,18 +127,18 @@
borders. This is done by assuming that the arrays are extended
beyond their boundaries according certain boundary conditions. In
the functions described below, the boundary conditions can be
-selected using the {mode} parameter which must be a string with the
+selected using the *mode* parameter which must be a string with the
name of the boundary condition. Following boundary conditions are
currently supported:
- {"nearest"} {Use the value at the boundary} {[1 2 3]->[1 1 2 3 3]}
- {"wrap"} {Periodically replicate the array} {[1 2 3]->[3 1 2 3 1]}
- {"reflect"} {Reflect the array at the boundary}
- {[1 2 3]->[1 1 2 3 3]}
- {"constant"} {Use a constant value, default value is 0.0}
- {[1 2 3]->[0 1 2 3 0]}
+ ========== ==================================== ====================
+ ------------------------------------------------------------------------
+ "nearest" Use the value at the boundary [1 2 3]->[1 1 2 3 3]
+ "wrap" Periodically replicate the array [1 2 3]->[3 1 2 3 1]
+ "reflect" Reflect the array at the boundary [1 2 3]->[1 1 2 3 3]
+ "constant" Use a constant value, default is 0.0 [1 2 3]->[0 1 2 3 0]
+ ========== ==================================== ====================
-
The {"constant"} mode is special since it needs an additional
parameter to specify the constant value that should be used.
@@ -150,19 +152,19 @@
Correlation and convolution
---------------------------
- The {correlate1d} function calculates a one-dimensional correlation
+ The :func:`correlate1d` function calculates a one-dimensional correlation
along the given axis. The lines of the array along the given axis
- are correlated with the given {weights}. The {weights} parameter
+ are correlated with the given *weights*. The *weights* parameter
must be a one-dimensional sequences of numbers.
- The function {correlate} implements multi-dimensional correlation
+ The function :func:`correlate` implements multi-dimensional correlation
of the input array with a given kernel.
- The {convolve1d} function calculates a one-dimensional convolution
+ The :func:`convolve1d` function calculates a one-dimensional convolution
along the given axis. The lines of the array along the given axis
- are convoluted with the given {weights}. The {weights} parameter
+ are convoluted with the given *weights*. The *weights* parameter
must be a one-dimensional sequences of numbers.
{A convolution is essentially a correlation after mirroring the
@@ -170,7 +172,7 @@
in the case of a correlation: the result is shifted in the opposite
directions.}
- The function {convolve} implements multi-dimensional convolution of
+ The function :func:`convolve` implements multi-dimensional convolution of
the input array with a given kernel.
{A convolution is essentially a correlation after mirroring the
@@ -178,31 +180,31 @@
in the case of a correlation: the results is shifted in the opposite
direction.}
-.. _ndimage_filter_functions_smoothing:
+.. _ndimage-filter-functions-smoothing:
Smoothing filters
-----------------
- The {gaussian_filter1d} function implements a one-dimensional
+ The :func:`gaussian_filter1d` function implements a one-dimensional
Gaussian filter. The standard-deviation of the Gaussian filter is
- passed through the parameter {sigma}. Setting {order}=0 corresponds
+ passed through the parameter *sigma*. Setting *order* = 0 corresponds
to convolution with a Gaussian kernel. An order of 1, 2, or 3
corresponds to convolution with the first, second or third
derivatives of a Gaussian. Higher order derivatives are not
implemented.
- The {gaussian_filter} function implements a multi-dimensional
+ The :func:`gaussian_filter` function implements a multi-dimensional
Gaussian filter. The standard-deviations of the Gaussian filter
- along each axis are passed through the parameter {sigma} as a
- sequence or numbers. If {sigma} is not a sequence but a single
+ along each axis are passed through the parameter *sigma* as a
+ sequence or numbers. If *sigma* is not a sequence but a single
number, the standard deviation of the filter is equal along all
directions. The order of the filter can be specified separately for
each axis. An order of 0 corresponds to convolution with a Gaussian
kernel. An order of 1, 2, or 3 corresponds to convolution with the
first, second or third derivatives of a Gaussian. Higher order
- derivatives are not implemented. The {order} parameter must be a
+ derivatives are not implemented. The *order* parameter must be a
number, to specify the same order for all axes, or a sequence of
numbers to specify a different order for each axis.
@@ -214,13 +216,13 @@
prevented by specifying a more precise output type.}
- The {uniform_filter1d} function calculates a one-dimensional
- uniform filter of the given {size} along the given axis.
+ The :func:`uniform_filter1d` function calculates a one-dimensional
+ uniform filter of the given *size* along the given axis.
- The {uniform_filter} implements a multi-dimensional uniform
+ The :func:`uniform_filter` implements a multi-dimensional uniform
filter. The sizes of the uniform filter are given for each axis as
- a sequence of integers by the {size} parameter. If {size} is not a
+ a sequence of integers by the *size* parameter. If *size* is not a
sequence, but a single number, the sizes along all axis are assumed
to be equal.
@@ -236,59 +238,59 @@
Filters based on order statistics
---------------------------------
- The {minimum_filter1d} function calculates a one-dimensional
- minimum filter of given {size} along the given axis.
+ The :func:`minimum_filter1d` function calculates a one-dimensional
+ minimum filter of given *size* along the given axis.
- The {maximum_filter1d} function calculates a one-dimensional
- maximum filter of given {size} along the given axis.
+ The :func:`maximum_filter1d` function calculates a one-dimensional
+ maximum filter of given *size* along the given axis.
- The {minimum_filter} function calculates a multi-dimensional
+ The :func:`minimum_filter` function calculates a multi-dimensional
minimum filter. Either the sizes of a rectangular kernel or the
- footprint of the kernel must be provided. The {size} parameter, if
+ footprint of the kernel must be provided. The *size* parameter, if
provided, must be a sequence of sizes or a single number in which
case the size of the filter is assumed to be equal along each axis.
- The {footprint}, if provided, must be an array that defines the
+ The *footprint*, if provided, must be an array that defines the
shape of the kernel by its non-zero elements.
- The {maximum_filter} function calculates a multi-dimensional
+ The :func:`maximum_filter` function calculates a multi-dimensional
maximum filter. Either the sizes of a rectangular kernel or the
- footprint of the kernel must be provided. The {size} parameter, if
+ footprint of the kernel must be provided. The *size* parameter, if
provided, must be a sequence of sizes or a single number in which
case the size of the filter is assumed to be equal along each axis.
- The {footprint}, if provided, must be an array that defines the
+ The *footprint*, if provided, must be an array that defines the
shape of the kernel by its non-zero elements.
- The {rank_filter} function calculates a multi-dimensional rank
- filter. The {rank} may be less then zero, i.e., {rank}=-1 indicates
+ The :func:`rank_filter` function calculates a multi-dimensional rank
+ filter. The *rank* may be less then zero, i.e., *rank* =-1 indicates
the largest element. Either the sizes of a rectangular kernel or
- the footprint of the kernel must be provided. The {size} parameter,
+ the footprint of the kernel must be provided. The *size* parameter,
if provided, must be a sequence of sizes or a single number in
which case the size of the filter is assumed to be equal along each
- axis. The {footprint}, if provided, must be an array that defines
+ axis. The *footprint*, if provided, must be an array that defines
the shape of the kernel by its non-zero elements.
- The {percentile_filter} function calculates a multi-dimensional
- percentile filter. The {percentile} may be less then zero, i.e.,
- {percentile}=-20 equals {percentile}=80. Either the sizes of a
+ The :func:`percentile_filter` function calculates a multi-dimensional
+ percentile filter. The *percentile* may be less then zero, i.e.,
+ *percentile* =-20 equals *percentile* =80. Either the sizes of a
rectangular kernel or the footprint of the kernel must be provided.
- The {size} parameter, if provided, must be a sequence of sizes or a
+ The *size* parameter, if provided, must be a sequence of sizes or a
single number in which case the size of the filter is assumed to be
- equal along each axis. The {footprint}, if provided, must be an
+ equal along each axis. The *footprint*, if provided, must be an
array that defines the shape of the kernel by its non-zero
elements.
- The {median_filter} function calculates a multi-dimensional median
+ The :func:`median_filter` function calculates a multi-dimensional median
filter. Either the sizes of a rectangular kernel or the footprint
- of the kernel must be provided. The {size} parameter, if provided,
+ of the kernel must be provided. The *size* parameter, if provided,
must be a sequence of sizes or a single number in which case the
size of the filter is assumed to be equal along each axis. The
- {footprint} if provided, must be an array that defines the shape of
+ *footprint* if provided, must be an array that defines the shape of
the kernel by its non-zero elements.
@@ -297,15 +299,15 @@
Derivative filters can be constructed in several ways. The function
{gaussian_filter1d} described in section
-:ref:`_ndimage_filter_functions_smoothing` can be used to calculate
-derivatives along a given axis using the {order} parameter. Other
+:ref:`ndimage-filter-functions-smoothing` can be used to calculate
+derivatives along a given axis using the *order* parameter. Other
derivative filters are the Prewitt and Sobel filters:
- The {prewitt} function calculates a derivative along the given
+ The :func:`prewitt` function calculates a derivative along the given
axis.
- The {sobel} function calculates a derivative along the given
+ The :func:`sobel` function calculates a derivative along the given
axis.
@@ -316,21 +318,21 @@
calculate the second derivative along a given direction and to
construct the Laplace filter:
- The function {generic_laplace} calculates a laplace filter using
- the function passed through {derivative2} to calculate second
- derivatives. The function {derivative2} should have the following
+ The function :func:`generic_laplace` calculates a laplace filter using
+ the function passed through :func:`derivative2` to calculate second
+ derivatives. The function :func:`derivative2` should have the following
signature:
{derivative2(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
It should calculate the second derivative along the dimension
- {axis}. If {output} is not {None} it should use that for the output
- and return {None}, otherwise it should return the result. {mode},
- {cval} have the usual meaning.
+ *axis*. If *output* is not {None} it should use that for the output
+ and return {None}, otherwise it should return the result. *mode*,
+ *cval* have the usual meaning.
- The {extra_arguments} and {extra_keywords} arguments can be used
+ The *extra_arguments* and *extra_keywords* arguments can be used
to pass a tuple of extra arguments and a dictionary of named
- arguments that are passed to {derivative2} at each call.
+ arguments that are passed to :func:`derivative2` at each call.
For example:
@@ -348,7 +350,7 @@
[ 0 0 1 0 0]
[ 0 0 0 0 0]]
- To demonstrate the use of the {extra_arguments} argument we could
+ To demonstrate the use of the *extra_arguments* argument we could
do:
::
@@ -378,44 +380,44 @@
The following two functions are implemented using
-{generic_laplace} by providing appropriate functions for the
+:func:`generic_laplace` by providing appropriate functions for the
second derivative function:
- The function {laplace} calculates the Laplace using discrete
+ The function :func:`laplace` calculates the Laplace using discrete
differentiation for the second derivative (i.e. convolution with
{[1, -2, 1]}).
- The function {gaussian_laplace} calculates the Laplace using
- {gaussian_filter} to calculate the second derivatives. The
+ The function :func:`gaussian_laplace` calculates the Laplace using
+ :func:`gaussian_filter` to calculate the second derivatives. The
standard-deviations of the Gaussian filter along each axis are
- passed through the parameter {sigma} as a sequence or numbers. If
- {sigma} is not a sequence but a single number, the standard
+ passed through the parameter *sigma* as a sequence or numbers. If
+ *sigma* is not a sequence but a single number, the standard
deviation of the filter is equal along all directions.
The gradient magnitude is defined as the square root of the sum of
the squares of the gradients in all directions. Similar to the
-generic Laplace function there is a {generic_gradient_magnitude}
+generic Laplace function there is a :func:`generic_gradient_magnitude`
function that calculated the gradient magnitude of an array:
- The function {generic_gradient_magnitude} calculates a gradient
- magnitude using the function passed through {derivative} to
- calculate first derivatives. The function {derivative} should have
+ The function :func:`generic_gradient_magnitude` calculates a gradient
+ magnitude using the function passed through :func:`derivative` to
+ calculate first derivatives. The function :func:`derivative` should have
the following signature:
{derivative(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
- It should calculate the derivative along the dimension {axis}. If
- {output} is not {None} it should use that for the output and return
- {None}, otherwise it should return the result. {mode}, {cval} have
+ It should calculate the derivative along the dimension *axis*. If
+ *output* is not {None} it should use that for the output and return
+ {None}, otherwise it should return the result. *mode*, *cval* have
the usual meaning.
- The {extra_arguments} and {extra_keywords} arguments can be used
+ The *extra_arguments* and *extra_keywords* arguments can be used
to pass a tuple of extra arguments and a dictionary of named
- arguments that are passed to {derivative} at each call.
+ arguments that are passed to *derivative* at each call.
- For example, the {sobel} function fits the required signature:
+ For example, the :func:`sobel` function fits the required signature:
::
@@ -428,28 +430,28 @@
[0 1 2 1 0]
[0 0 0 0 0]]
- See the documentation of {generic_laplace} for examples of using
- the {extra_arguments} and {extra_keywords} arguments.
+ See the documentation of :func:`generic_laplace` for examples of using
+ the *extra_arguments* and *extra_keywords* arguments.
-The {sobel} and {prewitt} functions fit the required signature and
-can therefore directly be used with {generic_gradient_magnitude}.
+The :func:`sobel` and :func:`prewitt` functions fit the required signature and
+can therefore directly be used with :func:`generic_gradient_magnitude`.
The following function implements the gradient magnitude using
Gaussian derivatives:
- The function {gaussian_gradient_magnitude} calculates the
- gradient magnitude using {gaussian_filter} to calculate the first
+ The function :func:`gaussian_gradient_magnitude` calculates the
+ gradient magnitude using :func:`gaussian_filter` to calculate the first
derivatives. The standard-deviations of the Gaussian filter along
- each axis are passed through the parameter {sigma} as a sequence or
- numbers. If {sigma} is not a sequence but a single number, the
+ each axis are passed through the parameter *sigma* as a sequence or
+ numbers. If *sigma* is not a sequence but a single number, the
standard deviation of the filter is equal along all directions.
+.. _ndimage-genericfilters:
+
Generic filter functions
------------------------
-.. _ndimage_genericfilters:
-
To implement filter functions, generic functions can be used that accept a
callable object that implements the filtering operation. The iteration over the
input and output arrays is handled by these generic functions, along with such
@@ -457,17 +459,17 @@
callable object implementing a callback function that does the
actual filtering work must be provided. The callback function can
also be written in C and passed using a CObject (see
-:ref:`_ndimage_ccallbacks` for more information).
+:ref:`ndimage-ccallbacks` for more information).
- The {generic_filter1d} function implements a generic
+ The :func:`generic_filter1d` function implements a generic
one-dimensional filter function, where the actual filtering
operation must be supplied as a python function (or other callable
- object). The {generic_filter1d} function iterates over the lines
- of an array and calls {function} at each line. The arguments that
- are passed to {function} are one-dimensional arrays of the
+ object). The :func:`generic_filter1d` function iterates over the lines
+ of an array and calls :func:`function` at each line. The arguments that
+ are passed to :func:`function` are one-dimensional arrays of the
{tFloat64} type. The first contains the values of the current line.
It is extended at the beginning end the end, according to the
- {filter_size} and {origin} arguments. The second array should be
+ *filter_size* and *origin* arguments. The second array should be
modified in-place to provide the output values of the line. For
example consider a correlation along one dimension:
@@ -479,7 +481,7 @@
[27 32 38 41]
[51 56 62 65]]
- The same operation can be implemented using {generic_filter1d} as
+ The same operation can be implemented using :func:`generic_filter1d` as
follows:
::
@@ -498,7 +500,7 @@
function was called.
Optionally extra arguments can be defined and passed to the filter
- function. The {extra_arguments} and {extra_keywords} arguments
+ function. The *extra_arguments* and *extra_keywords* arguments
can be used to pass a tuple of extra arguments and/or a dictionary
of named arguments that are passed to derivative at each call. For
example, we can pass the parameters of our filter as an argument:
@@ -523,11 +525,11 @@
[51 56 62 65]]
- The {generic_filter} function implements a generic filter
+ The :func:`generic_filter` function implements a generic filter
function, where the actual filtering operation must be supplied as
- a python function (or other callable object). The {generic_filter}
- function iterates over the array and calls {function} at each
- element. The argument of {function} is a one-dimensional array of
+ a python function (or other callable object). The :func:`generic_filter`
+ function iterates over the array and calls :func:`function` at each
+ element. The argument of :func:`function` is a one-dimensional array of
the {tFloat64} type, that contains the values around the current
element that are within the footprint of the filter. The function
should return a single value that can be converted to a double
@@ -541,7 +543,7 @@
[12 15 19 23]
[28 31 35 39]]
- The same operation can be implemented using {generic_filter} as
+ The same operation can be implemented using *generic_filter* as
follows:
::
@@ -559,15 +561,15 @@
equal to two, which was multiplied with the proper weights and the
result summed.
- When calling {generic_filter}, either the sizes of a rectangular
- kernel or the footprint of the kernel must be provided. The {size}
+ When calling :func:`generic_filter`, either the sizes of a rectangular
+ kernel or the footprint of the kernel must be provided. The *size*
parameter, if provided, must be a sequence of sizes or a single
number in which case the size of the filter is assumed to be equal
- along each axis. The {footprint}, if provided, must be an array
+ along each axis. The *footprint*, if provided, must be an array
that defines the shape of the kernel by its non-zero elements.
Optionally extra arguments can be defined and passed to the filter
- function. The {extra_arguments} and {extra_keywords} arguments
+ function. The *extra_arguments* and *extra_keywords* arguments
can be used to pass a tuple of extra arguments and/or a dictionary
of named arguments that are passed to derivative at each call. For
example, we can pass the parameters of our filter as an argument:
@@ -599,7 +601,7 @@
the filter dependening on spatial location. Here is an example of
using a class that implements the filter and keeps track of the
current coordinates while iterating. It performs the same filter
-operation as described above for {generic_filter}, but
+operation as described above for :func:`generic_filter`, but
additionally prints the current coordinates:
::
@@ -645,9 +647,9 @@
[12 15 19 23]
[28 31 35 39]]
-For the {generic_filter1d} function the same approach works,
+For the :func:`generic_filter1d` function the same approach works,
except that this function does not iterate over the axis that is
-being filtered. The example for {generic_filte1d} then becomes
+being filtered. The example for :func:`generic_filter1d` then becomes
this:
::
@@ -688,53 +690,53 @@
[51 56 62 65]]
Fourier domain filters
-======================
+----------------------
The functions described in this section perform filtering
operations in the Fourier domain. Thus, the input array of such a
function should be compatible with an inverse Fourier transform
-function, such as the functions from the {numarray.fft} module. We
+function, such as the functions from the {scipy.fft} module. We
therefore have to deal with arrays that may be the result of a real
or a complex Fourier transform. In the case of a real Fourier
transform only half of the of the symmetric complex transform is
stored. Additionally, it needs to be known what the length of the
axis was that was transformed by the real fft. The functions
-described here provide a parameter {n} that in the case of a real
+described here provide a parameter *n* that in the case of a real
transform must be equal to the length of the real transform axis
before transformation. If this parameter is less than zero, it is
assumed that the input array was the result of a complex Fourier
-transform. The parameter {axis} can be used to indicate along which
+transform. The parameter *axis* can be used to indicate along which
axis the real transform was executed.
- The {fourier_shift} function multiplies the input array with the
+ The :func:`fourier_shift` function multiplies the input array with the
multi-dimensional Fourier transform of a shift operation for the
- given shift. The {shift} parameter is a sequences of shifts for
+ given shift. The *shift* parameter is a sequences of shifts for
each dimension, or a single value for all dimensions.
- The {fourier_gaussian} function multiplies the input array with
+ The :func:`fourier_gaussian` function multiplies the input array with
the multi-dimensional Fourier transform of a Gaussian filter with
- given standard-deviations {sigma}. The {sigma} parameter is a
+ given standard-deviations *sigma*. The *sigma* parameter is a
sequences of values for each dimension, or a single value for all
dimensions.
- The {fourier_uniform} function multiplies the input array with the
+ The :func:`fourier_uniform` function multiplies the input array with the
multi-dimensional Fourier transform of a uniform filter with given
- sizes {size}. The {size} parameter is a sequences of values for
+ sizes *size*. The *size* parameter is a sequences of values for
each dimension, or a single value for all dimensions.
- The {fourier_ellipsoid} function multiplies the input array with
+ The :func:`fourier_ellipsoid` function multiplies the input array with
the multi-dimensional Fourier transform of a elliptically shaped
- filter with given sizes {size}. The {size} parameter is a sequences
+ filter with given sizes *size*. The *size* parameter is a sequences
of values for each dimension, or a single value for all dimensions.
{This function is
only implemented for dimensions 1, 2, and 3.}
Interpolation functions
-=======================
+-----------------------
This section describes various interpolation functions that are
based on B-spline theory. A good introduction to B-splines can be
@@ -743,22 +745,22 @@
22-38, November 1999. {Spline pre-filters} Interpolation using
splines of an order larger than 1 requires a pre- filtering step.
The interpolation functions described in section
-:ref:`_ndimage_interpolation` apply pre-filtering by calling
-{spline_filter}, but they can be instructed not to do this by
-setting the {prefilter} keyword equal to {False}. This is useful if
+:ref:`ndimage-interpolation` apply pre-filtering by calling
+:func:`spline_filter`, but they can be instructed not to do this by
+setting the *prefilter* keyword equal to {False}. This is useful if
more than one interpolation operation is done on the same array. In
this case it is more efficient to do the pre-filtering only once
and use a prefiltered array as the input of the interpolation
functions. The following two functions implement the
pre-filtering:
- The {spline_filter1d} function calculates a one-dimensional spline
+ The :func:`spline_filter1d` function calculates a one-dimensional spline
filter along the given axis. An output array can optionally be
provided. The order of the spline must be larger then 1 and less
than 6.
- The {spline_filter} function calculates a multi-dimensional spline
+ The :func:`spline_filter` function calculates a multi-dimensional spline
filter.
{The multi-dimensional filter is implemented as a sequence of
@@ -769,25 +771,25 @@
This can be prevented by specifying a output type of high precision.}
+.. _ndimage-interpolation:
+
Interpolation functions
-----------------------
-.. _ndimage_interpolation:
-
Following functions all employ spline interpolation to effect some type of
geometric transformation of the input array. This requires a mapping of the
output coordinates to the input coordinates, and therefore the possibility
arises that input values outside the boundaries are needed. This problem is
-solved in the same way as described in section :ref:`_ndimage_filter_functions`
+solved in the same way as described in section :ref:`ndimage-filter-functions`
for the multi-dimensional filter functions. Therefore these functions all
-support a {mode} parameter that determines how the boundaries are handled, and
-a {cval} parameter that gives a constant value in case that the {'constant'}
+support a *mode* parameter that determines how the boundaries are handled, and
+a *cval* parameter that gives a constant value in case that the {'constant'}
mode is used.
- The {geometric_transform} function applies an arbitrary geometric
- transform to the input. The given {mapping} function is called at
+ The :func:`geometric_transform` function applies an arbitrary geometric
+ transform to the input. The given *mapping* function is called at
each point in the output to find the corresponding coordinates in
- the input. {mapping} must be a callable object that accepts a tuple
+ the input. *mapping* must be a callable object that accepts a tuple
of length equal to the output array rank and returns the
corresponding input coordinates as a tuple of length equal to the
input array rank. The output shape and output type can optionally
@@ -809,7 +811,7 @@
[ 0. 8.2625 9.6375]]
Optionally extra arguments can be defined and passed to the filter
- function. The {extra_arguments} and {extra_keywords} arguments
+ function. The *extra_arguments* and *extra_keywords* arguments
can be used to pass a tuple of extra arguments and/or a dictionary
of named arguments that are passed to derivative at each call. For
example, we can pass the shifts in our example as arguments:
@@ -835,17 +837,17 @@
[ 0. 4.8125 6.1875]
[ 0. 8.2625 9.6375]]
- {The mapping function can also be written in C and passed using a CObject. See :ref:`_ndimage_ccallbacks` for more information.}
+ {The mapping function can also be written in C and passed using a CObject. See :ref:`ndimage-ccallbacks` for more information.}
- The function {map_coordinates} applies an arbitrary coordinate
+ The function :func:`map_coordinates` applies an arbitrary coordinate
transformation using the given array of coordinates. The shape of
the output is derived from that of the coordinate array by dropping
- the first axis. The parameter {coordinates} is used to find for
+ the first axis. The parameter *coordinates* is used to find for
each point in the output the corresponding coordinates in the
- input. The values of {coordinates} along the first axis are the
+ input. The values of *coordinates* along the first axis are the
coordinates in the input array at which the output value is found.
- (See also the numarray {coordinates} function.) Since the
+ (See also the numarray *coordinates* function.) Since the
coordinates may be non- integer coordinates, the value of the input
at these coordinates is determined by spline interpolation of the
requested order. Here is an example that interpolates a 2D array at
@@ -863,12 +865,12 @@
[ 1.3625 7. ]
- The {affine_transform} function applies an affine transformation
- to the input array. The given transformation {matrix} and {offset}
+ The :func:`affine_transform` function applies an affine transformation
+ to the input array. The given transformation *matrix* and *offset*
are used to find for each point in the output the corresponding
coordinates in the input. The value of the input at the calculated
coordinates is determined by spline interpolation of the requested
- order. The transformation {matrix} must be two-dimensional or can
+ order. The transformation *matrix* must be two-dimensional or can
also be given as a one-dimensional sequence or array. In the latter
case, it is assumed that the matrix is diagonal. A more efficient
interpolation algorithm is then applied that exploits the
@@ -877,33 +879,33 @@
shape and type.
- The {shift} function returns a shifted version of the input, using
- spline interpolation of the requested {order}.
+ The :func:`shift` function returns a shifted version of the input, using
+ spline interpolation of the requested *order*.
- The {zoom} function returns a rescaled version of the input, using
- spline interpolation of the requested {order}.
+ The :func:`zoom` function returns a rescaled version of the input, using
+ spline interpolation of the requested *order*.
- The {rotate} function returns the input array rotated in the plane
- defined by the two axes given by the parameter {axes}, using spline
- interpolation of the requested {order}. The angle must be given in
- degrees. If {reshape} is true, then the size of the output array is
+ The :func:`rotate` function returns the input array rotated in the plane
+ defined by the two axes given by the parameter *axes*, using spline
+ interpolation of the requested *order*. The angle must be given in
+ degrees. If *reshape* is true, then the size of the output array is
adapted to contain the rotated input.
+.. _ndimage-binary-morphology:
+
Binary morphology
-=================
+-----------------
-.. _ndimage_binary_morphology:
-
- The {generate_binary_structure} functions generates a binary
+ The :func:`generate_binary_structure` functions generates a binary
structuring element for use in binary morphology operations. The
- {rank} of the structure must be provided. The size of the structure
+ *rank* of the structure must be provided. The size of the structure
that is returned is equal to three in each direction. The value of
each element is equal to one if the square of the Euclidean
distance from the element to the center is less or equal to
- {connectivity}. For instance, two dimensional 4-connected and
+ *connectivity*. For instance, two dimensional 4-connected and
8-connected structures are generated as follows:
::
@@ -921,34 +923,34 @@
Most binary morphology functions can be expressed in terms of the
basic operations erosion and dilation:
- The {binary_erosion} function implements binary erosion of arrays
+ The :func:`binary_erosion` function implements binary erosion of arrays
of arbitrary rank with the given structuring element. The origin
parameter controls the placement of the structuring element as
- described in section :ref:`_ndimage_filter_functions`. If no
+ described in section :ref:`ndimage-filter-functions`. If no
structuring element is provided, an element with connectivity equal
- to one is generated using {generate_binary_structure}. The
- {border_value} parameter gives the value of the array outside
- boundaries. The erosion is repeated {iterations} times. If
- {iterations} is less than one, the erosion is repeated until the
- result does not change anymore. If a {mask} array is given, only
+ to one is generated using :func:`generate_binary_structure`. The
+ *border_value* parameter gives the value of the array outside
+ boundaries. The erosion is repeated *iterations* times. If
+ *iterations* is less than one, the erosion is repeated until the
+ result does not change anymore. If a *mask* array is given, only
those elements with a true value at the corresponding mask element
are modified at each iteration.
- The {binary_dilation} function implements binary dilation of
+ The :func:`binary_dilation` function implements binary dilation of
arrays of arbitrary rank with the given structuring element. The
origin parameter controls the placement of the structuring element
- as described in section :ref:`_ndimage_filter_functions`. If no
+ as described in section :ref:`ndimage-filter-functions`. If no
structuring element is provided, an element with connectivity equal
- to one is generated using {generate_binary_structure}. The
- {border_value} parameter gives the value of the array outside
- boundaries. The dilation is repeated {iterations} times. If
- {iterations} is less than one, the dilation is repeated until the
- result does not change anymore. If a {mask} array is given, only
+ to one is generated using :func:`generate_binary_structure`. The
+ *border_value* parameter gives the value of the array outside
+ boundaries. The dilation is repeated *iterations* times. If
+ *iterations* is less than one, the dilation is repeated until the
+ result does not change anymore. If a *mask* array is given, only
those elements with a true value at the corresponding mask element
are modified at each iteration.
- Here is an example of using {binary_dilation} to find all elements
+ Here is an example of using :func:`binary_dilation` to find all elements
that touch the border, by repeatedly dilating an empty array from
the border using the data array as the mask:
@@ -968,16 +970,16 @@
[0 0 0 0 0]]
-The {binary_erosion} and {binary_dilation} functions both have an
-{iterations} parameter which allows the erosion or dilation to be
+The :func:`binary_erosion` and :func:`binary_dilation` functions both have an
+*iterations* parameter which allows the erosion or dilation to be
repeated a number of times. Repeating an erosion or a dilation with
-a given structure {n} times is equivalent to an erosion or a
+a given structure *n* times is equivalent to an erosion or a
dilation with a structure that is {n-1} times dilated with itself.
A function is provided that allows the calculation of a structure
that is dilated a number of times with itself:
- The {iterate_structure} function returns a structure by dilation
- of the input structure {iteration} - 1 times with itself. For
+ The :func:`iterate_structure` function returns a structure by dilation
+ of the input structure *iteration* - 1 times with itself. For
instance:
::
@@ -996,11 +998,11 @@
If the origin of the original structure is equal to 0, then it is
also equal to 0 for the iterated structure. If not, the origin must
- also be adapted if the equivalent of the {iterations} erosions or
+ also be adapted if the equivalent of the *iterations* erosions or
dilations must be achieved with the iterated structure. The adapted
origin is simply obtained by multiplying with the number of
- iterations. For convenience the {iterate_structure} also returns
- the adapted origin if the {origin} parameter is not {None}:
+ iterations. For convenience the :func:`iterate_structure` also returns
+ the adapted origin if the *origin* parameter is not {None}:
::
@@ -1016,151 +1018,149 @@
d dilation. Following functions provide a few of these operations
for convenience:
- The {binary_opening} function implements binary opening of arrays
+ The :func:`binary_opening` function implements binary opening of arrays
of arbitrary rank with the given structuring element. Binary
opening is equivalent to a binary erosion followed by a binary
dilation with the same structuring element. The origin parameter
controls the placement of the structuring element as described in
- section :ref:`_ndimage_filter_functions`. If no structuring element is
+ section :ref:`ndimage-filter-functions`. If no structuring element is
provided, an element with connectivity equal to one is generated
- using {generate_binary_structure}. The {iterations} parameter
+ using :func:`generate_binary_structure`. The *iterations* parameter
gives the number of erosions that is performed followed by the same
number of dilations.
- The {binary_closing} function implements binary closing of arrays
+ The :func:`binary_closing` function implements binary closing of arrays
of arbitrary rank with the given structuring element. Binary
closing is equivalent to a binary dilation followed by a binary
erosion with the same structuring element. The origin parameter
controls the placement of the structuring element as described in
- section :ref:`_ndimage_filter_functions`. If no structuring element is
+ section :ref:`ndimage-filter-functions`. If no structuring element is
provided, an element with connectivity equal to one is generated
- using {generate_binary_structure}. The {iterations} parameter
+ using :func:`generate_binary_structure`. The *iterations* parameter
gives the number of dilations that is performed followed by the
same number of erosions.
- The {binary_fill_holes} function is used to close holes in
+ The :func:`binary_fill_holes` function is used to close holes in
objects in a binary image, where the structure defines the
connectivity of the holes. The origin parameter controls the
placement of the structuring element as described in section
- :ref:`_ndimage_filter_functions`. If no structuring element is
+ :ref:`ndimage-filter-functions`. If no structuring element is
provided, an element with connectivity equal to one is generated
- using {generate_binary_structure}.
+ using :func:`generate_binary_structure`.
- The {binary_hit_or_miss} function implements a binary
+ The :func:`binary_hit_or_miss` function implements a binary
hit-or-miss transform of arrays of arbitrary rank with the given
structuring elements. The hit-or-miss transform is calculated by
erosion of the input with the first structure, erosion of the
logical *not* of the input with the second structure, followed by
the logical *and* of these two erosions. The origin parameters
control the placement of the structuring elements as described in
- section :ref:`_ndimage_filter_functions`. If {origin2} equals {None} it
+ section :ref:`ndimage-filter-functions`. If {origin2} equals {None} it
is set equal to the {origin1} parameter. If the first structuring
element is not provided, a structuring element with connectivity
- equal to one is generated using {generate_binary_structure}, if
+ equal to one is generated using :func:`generate_binary_structure`, if
{structure2} is not provided, it is set equal to the logical *not*
of {structure1}.
+.. _ndimage-grey-morphology:
+
Grey-scale morphology
-=====================
+---------------------
-.. _ndimage_grey_morphology:
-
-
-
Grey-scale morphology operations are the equivalents of binary
morphology operations that operate on arrays with arbitrary values.
Below we describe the grey-scale equivalents of erosion, dilation,
opening and closing. These operations are implemented in a similar
fashion as the filters described in section
-:ref:`_ndimage_filter_functions`, and we refer to this section for the
+:ref:`ndimage-filter-functions`, and we refer to this section for the
description of filter kernels and footprints, and the handling of
array borders. The grey-scale morphology operations optionally take
-a {structure} parameter that gives the values of the structuring
+a *structure* parameter that gives the values of the structuring
element. If this parameter is not given the structuring element is
assumed to be flat with a value equal to zero. The shape of the
-structure can optionally be defined by the {footprint} parameter.
+structure can optionally be defined by the *footprint* parameter.
If this parameter is not given, the structure is assumed to be
-rectangular, with sizes equal to the dimensions of the {structure}
-array, or by the {size} parameter if {structure} is not given. The
-{size} parameter is only used if both {structure} and {footprint}
+rectangular, with sizes equal to the dimensions of the *structure*
+array, or by the *size* parameter if *structure* is not given. The
+*size* parameter is only used if both *structure* and *footprint*
are not given, in which case the structuring element is assumed to
-be rectangular and flat with the dimensions given by {size}. The
-{size} parameter, if provided, must be a sequence of sizes or a
+be rectangular and flat with the dimensions given by *size*. The
+*size* parameter, if provided, must be a sequence of sizes or a
single number in which case the size of the filter is assumed to be
-equal along each axis. The {footprint} parameter, if provided, must
+equal along each axis. The *footprint* parameter, if provided, must
be an array that defines the shape of the kernel by its non-zero
elements.
Similar to binary erosion and dilation there are operations for
grey-scale erosion and dilation:
- The {grey_erosion} function calculates a multi-dimensional grey-
+ The :func:`grey_erosion` function calculates a multi-dimensional grey-
scale erosion.
- The {grey_dilation} function calculates a multi-dimensional grey-
+ The :func:`grey_dilation` function calculates a multi-dimensional grey-
scale dilation.
Grey-scale opening and closing operations can be defined similar to
their binary counterparts:
- The {grey_opening} function implements grey-scale opening of
+ The :func:`grey_opening` function implements grey-scale opening of
arrays of arbitrary rank. Grey-scale opening is equivalent to a
grey-scale erosion followed by a grey-scale dilation.
- The {grey_closing} function implements grey-scale closing of
+ The :func:`grey_closing` function implements grey-scale closing of
arrays of arbitrary rank. Grey-scale opening is equivalent to a
grey-scale dilation followed by a grey-scale erosion.
- The {morphological_gradient} function implements a grey-scale
+ The :func:`morphological_gradient` function implements a grey-scale
morphological gradient of arrays of arbitrary rank. The grey-scale
morphological gradient is equal to the difference of a grey-scale
dilation and a grey-scale erosion.
- The {morphological_laplace} function implements a grey-scale
+ The :func:`morphological_laplace` function implements a grey-scale
morphological laplace of arrays of arbitrary rank. The grey-scale
morphological laplace is equal to the sum of a grey-scale dilation
and a grey-scale erosion minus twice the input.
- The {white_tophat} function implements a white top-hat filter of
+ The :func:`white_tophat` function implements a white top-hat filter of
arrays of arbitrary rank. The white top-hat is equal to the
difference of the input and a grey-scale opening.
- The {black_tophat} function implements a black top-hat filter of
+ The :func:`black_tophat` function implements a black top-hat filter of
arrays of arbitrary rank. The black top-hat is equal to the
difference of the a grey-scale closing and the input.
+.. _ndimage-distance-transforms:
+
Distance transforms
-===================
+-------------------
-.. _ndimage_distance_transforms:
-
Distance transforms are used to
calculate the minimum distance from each element of an object to
the background. The following functions implement distance
transforms for three different distance metrics: Euclidean, City
Block, and Chessboard distances.
- The function {distance_transform_cdt} uses a chamfer type
+ The function :func:`distance_transform_cdt` uses a chamfer type
algorithm to calculate the distance transform of the input, by
replacing each object element (defined by values larger than zero)
with the shortest distance to the background (all non-object
elements). The structure determines the type of chamfering that is
done. If the structure is equal to 'cityblock' a structure is
- generated using {generate_binary_structure} with a squared
+ generated using :func:`generate_binary_structure` with a squared
distance equal to 1. If the structure is equal to 'chessboard', a
- structure is generated using {generate_binary_structure} with a
+ structure is generated using :func:`generate_binary_structure` with a
squared distance equal to the rank of the array. These choices
correspond to the common interpretations of the cityblock and the
chessboard distancemetrics in two dimensions.
@@ -1168,11 +1168,11 @@
In addition to the distance transform, the feature transform can be
calculated. In this case the index of the closest background
element is returned along the first axis of the result. The
- {return_distances}, and {return_indices} flags can be used to
+ *return_distances*, and *return_indices* flags can be used to
indicate if the distance transform, the feature transform, or both
must be returned.
- The {distances} and {indices} arguments can be used to give
+ The *distances* and *indices* arguments can be used to give
optional output arrays that must be of the correct size and type
(both {Int32}).
@@ -1182,7 +1182,7 @@
27:321-345, 1984.
- The function {distance_transform_edt} calculates the exact
+ The function :func:`distance_transform_edt` calculates the exact
euclidean distance transform of the input, by replacing each object
element (defined by values larger than zero) with the shortest
euclidean distance to the background (all non-object elements).
@@ -1190,16 +1190,16 @@
In addition to the distance transform, the feature transform can be
calculated. In this case the index of the closest background
element is returned along the first axis of the result. The
- {return_distances}, and {return_indices} flags can be used to
+ *return_distances*, and *return_indices* flags can be used to
indicate if the distance transform, the feature transform, or both
must be returned.
Optionally the sampling along each axis can be given by the
- {sampling} parameter which should be a sequence of length equal to
+ *sampling* parameter which should be a sequence of length equal to
the input rank, or a single number in which the sampling is assumed
to be equal along all axes.
- The {distances} and {indices} arguments can be used to give
+ The *distances* and *indices* arguments can be used to give
optional output arrays that must be of the correct size and type
({Float64} and {Int32}).
@@ -1209,7 +1209,7 @@
in arbitrary dimensions. IEEE Trans. PAMI 25, 265-270, 2003.
- The function {distance_transform_bf} uses a brute-force algorithm
+ The function :func:`distance_transform_bf` uses a brute-force algorithm
to calculate the distance transform of the input, by replacing each
object element (defined by values larger than zero) with the
shortest distance to the background (all non-object elements). The
@@ -1219,17 +1219,17 @@
In addition to the distance transform, the feature transform can be
calculated. In this case the index of the closest background
element is returned along the first axis of the result. The
- {return_distances}, and {return_indices} flags can be used to
+ *return_distances*, and *return_indices* flags can be used to
indicate if the distance transform, the feature transform, or both
must be returned.
Optionally the sampling along each axis can be given by the
- {sampling} parameter which should be a sequence of length equal to
+ *sampling* parameter which should be a sequence of length equal to
the input rank, or a single number in which the sampling is assumed
to be equal along all axes. This parameter is only used in the case
of the euclidean distance transform.
- The {distances} and {indices} arguments can be used to give
+ The *distances* and *indices* arguments can be used to give
optional output arrays that must be of the correct size and type
({Float64} and {Int32}).
@@ -1241,11 +1241,11 @@
Segmentation and labeling
-=========================
+-------------------------
Segmentation is the process of separating objects of interest from
the background. The most simple approach is probably intensity
-thresholding, which is easily done with {numarray} functions:
+thresholding, which is easily done with :mod:`numpy` functions:
::
@@ -1260,13 +1260,13 @@
[0 0 0 0 1 0]]
The result is a binary image, in which the individual objects still
-need to be identified and labeled. The function {label} generates
+need to be identified and labeled. The function :func:`label` generates
an array where each object is assigned a unique number:
- The {label} function generates an array where the objects in the
+ The :func:`label` function generates an array where the objects in the
input are labeled with an integer index. It returns a tuple
consisting of the array of object labels and the number of objects
- found, unless the {output} parameter is given, in which case only
+ found, unless the *output* parameter is given, in which case only
the number of objects is returned. The connectivity of the objects
is defined by a structuring element. For instance, in two
dimensions using a four-connected structuring element gives:
@@ -1297,7 +1297,7 @@
[0 0 0 0 1 0]]
If no structuring element is provided, one is generated by calling
- {generate_binary_structure} (see section :ref:`_ndimage_morphology`)
+ *generate_binary_structure* (see section :ref:`ndimage-binary-morphology`)
using a connectivity of one (which in 2D is the 4-connected
structure of the first example). The input can be of any type, any
value not equal to zero is taken to be part of an object. This is
@@ -1323,13 +1323,13 @@
There is a large number of other approaches for segmentation, for
instance from an estimation of the borders of the objects that can
be obtained for instance by derivative filters. One such an
-approach is watershed segmentation. The function {watershed_ift}
+approach is watershed segmentation. The function :func:`watershed_ift`
generates an array where each object is assigned a unique label,
from an array that localizes the object borders, generated for
instance by a gradient magnitude filter. It uses an array
containing initial markers for the objects:
- The {watershed_ift} function applies a watershed from markers
+ The :func:`watershed_ift` function applies a watershed from markers
algorithm, using an Iterative Forest Transform, as described in: P.
Felkel, R. Wegenkittl, and M. Bruckschwaiger, "Implementation and
Complexity of the Watershed-from-Markers Algorithm Computed as a
@@ -1390,7 +1390,7 @@
The result is that the object (marker=2) is smaller because the
second marker was processed earlier. This may not be the desired
effect if the first marker was supposed to designate a background
- object. Therefore {watershed_ift} treats markers with a negative
+ object. Therefore :func:`watershed_ift` treats markers with a negative
value explicitly as background markers and processes them after the
normal markers. For instance, replacing the first marker by a
negative marker gives a result similar to the first example:
@@ -1415,10 +1415,10 @@
The connectivity of the objects is defined by a structuring
element. If no structuring element is provided, one is generated by
- calling {generate_binary_structure} (see section
- :ref:`_ndimage_morphology`) using a connectivity of one (which in 2D is
- a 4-connected structure.) For example, using an 8-connected
- structure with the last example yields a different object:
+ calling :func:`generate_binary_structure` (see section
+ :ref:`ndimage-binary-morphology`) using a connectivity of one
+ (which in 2D is a 4-connected structure.) For example, using
+ an 8-connected structure with the last example yields a different object:
::
@@ -1437,14 +1437,14 @@
Object measurements
-===================
+-------------------
Given an array of labeled objects, the properties of the individual
-objects can be measured. The {find_objects} function can be used
+objects can be measured. The :func:`find_objects` function can be used
to generate a list of slices that for each object, give the
smallest sub-array that fully contains the object:
- The {find_objects} finds all objects in a labeled array and
+ The :func:`find_objects` function finds all objects in a labeled array and
returns a list of slices that correspond to the smallest regions in
the array that contains the object. For instance:
@@ -1461,10 +1461,10 @@
[1 1 1]
[0 1 0]]
- {find_objects} returns slices for all objects, unless the
- {max_label} parameter is larger then zero, in which case only the
- first {max_label} objects are returned. If an index is missing in
- the {label} array, {None} is return instead of a slice. For
+ :func:`find_objects` returns slices for all objects, unless the
+ *max_label* parameter is larger then zero, in which case only the
+ first *max_label* objects are returned. If an index is missing in
+ the *label* array, {None} is return instead of a slice. For
example:
::
@@ -1473,7 +1473,7 @@
[(slice(0, 1, None),), None, (slice(2, 3, None),)]
-The list of slices generated by {find_objects} is useful to find
+The list of slices generated by :func:`find_objects` is useful to find
the position and dimensions of the objects in the array, but can
also be used to perform measurements on the individual objects. Say
we want to find the sum of the intensities of an object in image:
@@ -1522,118 +1522,118 @@
>>> print sum(image, labels, [0, 2])
[178.0, 80.0]
-The measurement functions described below all support the {index}
+The measurement functions described below all support the *index*
parameter to indicate which object(s) should be measured. The
-default value of {index} is {None}. This indicates that all
+default value of *index* is {None}. This indicates that all
elements where the label is larger than zero should be treated as a
-single object and measured. Thus, in this case the {labels} array
+single object and measured. Thus, in this case the *labels* array
is treated as a mask defined by the elements that are larger than
-zero. If {index} is a number or a sequence of numbers it gives the
-labels of the objects that are measured. If {index} is a sequence,
+zero. If *index* is a number or a sequence of numbers it gives the
+labels of the objects that are measured. If *index* is a sequence,
a list of the results is returned. Functions that return more than
-one result, return their result as a tuple if {index} is a single
-number, or as a tuple of lists, if {index} is a sequence.
+one result, return their result as a tuple if *index* is a single
+number, or as a tuple of lists, if *index* is a sequence.
- The {sum} function calculates the sum of the elements of the object
- with label(s) given by {index}, using the {labels} array for the
- object labels. If {index} is {None}, all elements with a non-zero
- label value are treated as a single object. If {label} is {None},
- all elements of {input} are used in the calculation.
+ The :func:`sum` function calculates the sum of the elements of the object
+ with label(s) given by *index*, using the *labels* array for the
+ object labels. If *index* is {None}, all elements with a non-zero
+ label value are treated as a single object. If *label* is {None},
+ all elements of *input* are used in the calculation.
- The {mean} function calculates the mean of the elements of the
- object with label(s) given by {index}, using the {labels} array for
- the object labels. If {index} is {None}, all elements with a
- non-zero label value are treated as a single object. If {label} is
- {None}, all elements of {input} are used in the calculation.
+ The :func:`mean` function calculates the mean of the elements of the
+ object with label(s) given by *index*, using the *labels* array for
+ the object labels. If *index* is {None}, all elements with a
+ non-zero label value are treated as a single object. If *label* is
+ {None}, all elements of *input* are used in the calculation.
- The {variance} function calculates the variance of the elements of
- the object with label(s) given by {index}, using the {labels} array
- for the object labels. If {index} is {None}, all elements with a
- non-zero label value are treated as a single object. If {label} is
- {None}, all elements of {input} are used in the calculation.
+ The :func:`variance` function calculates the variance of the elements of
+ the object with label(s) given by *index*, using the *labels* array
+ for the object labels. If *index* is {None}, all elements with a
+ non-zero label value are treated as a single object. If *label* is
+ {None}, all elements of *input* are used in the calculation.
- The {standard_deviation} function calculates the standard
+ The :func:`standard_deviation` function calculates the standard
deviation of the elements of the object with label(s) given by
- {index}, using the {labels} array for the object labels. If {index}
+ *index*, using the *labels* array for the object labels. If *index*
is {None}, all elements with a non-zero label value are treated as
- a single object. If {label} is {None}, all elements of {input} are
+ a single object. If *label* is {None}, all elements of *input* are
used in the calculation.
- The {minimum} function calculates the minimum of the elements of
- the object with label(s) given by {index}, using the {labels} array
- for the object labels. If {index} is {None}, all elements with a
- non-zero label value are treated as a single object. If {label} is
- {None}, all elements of {input} are used in the calculation.
+ The :func:`minimum` function calculates the minimum of the elements of
+ the object with label(s) given by *index*, using the *labels* array
+ for the object labels. If *index* is {None}, all elements with a
+ non-zero label value are treated as a single object. If *label* is
+ {None}, all elements of *input* are used in the calculation.
- The {maximum} function calculates the maximum of the elements of
- the object with label(s) given by {index}, using the {labels} array
- for the object labels. If {index} is {None}, all elements with a
- non-zero label value are treated as a single object. If {label} is
- {None}, all elements of {input} are used in the calculation.
+ The :func:`maximum` function calculates the maximum of the elements of
+ the object with label(s) given by *index*, using the *labels* array
+ for the object labels. If *index* is {None}, all elements with a
+ non-zero label value are treated as a single object. If *label* is
+ {None}, all elements of *input* are used in the calculation.
- The {minimum_position} function calculates the position of the
+ The :func:`minimum_position` function calculates the position of the
minimum of the elements of the object with label(s) given by
- {index}, using the {labels} array for the object labels. If {index}
+ *index*, using the *labels* array for the object labels. If *index*
is {None}, all elements with a non-zero label value are treated as
- a single object. If {label} is {None}, all elements of {input} are
+ a single object. If *label* is {None}, all elements of *input* are
used in the calculation.
- The {maximum_position} function calculates the position of the
+ The :func:`maximum_position` function calculates the position of the
maximum of the elements of the object with label(s) given by
- {index}, using the {labels} array for the object labels. If {index}
+ *index*, using the *labels* array for the object labels. If *index*
is {None}, all elements with a non-zero label value are treated as
- a single object. If {label} is {None}, all elements of {input} are
+ a single object. If *label* is {None}, all elements of *input* are
used in the calculation.
- The {extrema} function calculates the minimum, the maximum, and
+ The :func:`extrema` function calculates the minimum, the maximum, and
their positions, of the elements of the object with label(s) given
- by {index}, using the {labels} array for the object labels. If
- {index} is {None}, all elements with a non-zero label value are
- treated as a single object. If {label} is {None}, all elements of
- {input} are used in the calculation. The result is a tuple giving
+ by *index*, using the *labels* array for the object labels. If
+ *index* is {None}, all elements with a non-zero label value are
+ treated as a single object. If *label* is {None}, all elements of
+ *input* are used in the calculation. The result is a tuple giving
the minimum, the maximum, the position of the mininum and the
postition of the maximum. The result is the same as a tuple formed
- by the results of the functions {minimum}, {maximum},
- {minimum_position}, and {maximum_position} that are described
+ by the results of the functions *minimum*, *maximum*,
+ *minimum_position*, and *maximum_position* that are described
above.
- The {center_of_mass} function calculates the center of mass of
- the of the object with label(s) given by {index}, using the
- {labels} array for the object labels. If {index} is {None}, all
+ The :func:`center_of_mass` function calculates the center of mass of
+ the of the object with label(s) given by *index*, using the
+ *labels* array for the object labels. If *index* is {None}, all
elements with a non-zero label value are treated as a single
- object. If {label} is {None}, all elements of {input} are used in
+ object. If *label* is {None}, all elements of *input* are used in
the calculation.
- The {histogram} function calculates a histogram of the of the
- object with label(s) given by {index}, using the {labels} array for
- the object labels. If {index} is {None}, all elements with a
- non-zero label value are treated as a single object. If {label} is
- {None}, all elements of {input} are used in the calculation.
- Histograms are defined by their minimum ({min}), maximum ({max})
- and the number of bins ({bins}). They are returned as
+ The :func:`histogram` function calculates a histogram of the of the
+ object with label(s) given by *index*, using the *labels* array for
+ the object labels. If *index* is {None}, all elements with a
+ non-zero label value are treated as a single object. If *label* is
+ {None}, all elements of *input* are used in the calculation.
+ Histograms are defined by their minimum (*min*), maximum (*max*)
+ and the number of bins (*bins*). They are returned as
one-dimensional arrays of type Int32.
-Extending {nd_image} in C
-============================
+.. _ndimage-ccallbacks:
-.. _ndimage_ccallbacks:
+Extending *ndimage* in C
+-------------------------
-{C callback functions} A few functions in the {numarray.nd_image} take a call-back argument. This can be a python function, but also a CObject containing a pointer to a C function. To use this feature, you must write your own C extension that defines the function, and define a python function that
+{C callback functions} A few functions in the {numarray.ndimage} take a call-back argument. This can be a python function, but also a CObject containing a pointer to a C function. To use this feature, you must write your own C extension that defines the function, and define a python function that
returns a CObject containing a pointer to this function.
An example of a function that supports this is
-{geometric_transform} (see section :ref:`_ndimage_interpolation`).
+:func:`geometric_transform` (see section :ref:`ndimage-interpolation`).
You can pass it a python callable object that defines a mapping
from all output coordinates to corresponding coordinates in the
input array. This mapping function can also be a C function, which
@@ -1660,17 +1660,17 @@
}
This function is called at every element of the output array,
-passing the current coordinates in the {output_coordinates} array.
-On return, the {input_coordinates} array must contain the
+passing the current coordinates in the *output_coordinates* array.
+On return, the *input_coordinates* array must contain the
coordinates at which the input is interpolated. The ranks of the
-input and output array are passed through {output_rank} and
-{input_rank}. The value of the shift is passed through the
-{callback_data} argument, which is a pointer to void. The function
+input and output array are passed through *output_rank* and
+*input_rank*. The value of the shift is passed through the
+*callback_data* argument, which is a pointer to void. The function
returns an error status, in this case always 1, since no error can
occur.
A pointer to this function and a pointer to the shift value must be
-passed to {geometric_transform}. Both are passed by a single
+passed to :func:`geometric_transform`. Both are passed by a single
CObject which is created by the following python extension
function:
@@ -1737,23 +1737,23 @@
[ 0. 4.8125 6.1875]
[ 0. 8.2625 9.6375]]
-C Callback functions for use with {nd_image} functions must all
+C Callback functions for use with :mod:`ndimage` functions must all
be written according to this scheme. The next section lists the
-{nd_image} functions that acccept a C callback function and
+:mod:`ndimage` functions that acccept a C callback function and
gives the prototype of the callback function.
Functions that support C callback functions
-------------------------------------------
-The {nd_image} functions that support C callback functions are
+The :func:`ndimage` functions that support C callback functions are
described here. Obviously, the prototype of the function that is
provided to these functions must match exactly that what they
expect. Therefore we give here the prototypes of the callback
functions. All these callback functions accept a void
-{callback_data} pointer that must be wrapped in a CObject using
+*callback_data* pointer that must be wrapped in a CObject using
the Python {PyCObject_FromVoidPtrAndDesc} function, which can also
accept a pointer to a destructor function to free any memory
-allocated for {callback_data}. If {callback_data} is not needed,
+allocated for *callback_data*. If *callback_data* is not needed,
{PyCObject_FromVoidPtr} may be used instead. The callback
functions must return an integer error status that is equal to zero
if something went wrong, or 1 otherwise. If an error occurs, you
@@ -1761,45 +1761,45 @@
message before returning, otherwise, a default error message is set
by the calling function.
-The function {generic_filter} (see section
-:ref:`_ndimage_genericfilters`) accepts a callback function with the
+The function :func:`generic_filter` (see section
+:ref:`ndimage-genericfilters`) accepts a callback function with the
following prototype:
The calling function iterates over the elements of the input and
output arrays, calling the callback function at each element. The
elements within the footprint of the filter at the current element
- are passed through the {buffer} parameter, and the number of
- elements within the footprint through {filter_size}. The
- calculated valued should be returned in the {return_value}
+ are passed through the *buffer* parameter, and the number of
+ elements within the footprint through *filter_size*. The
+ calculated valued should be returned in the *return_value*
argument.
-The function {generic_filter1d} (see section
-:ref:`_ndimage_genericfilters`) accepts a callback function with the
+The function :func:`generic_filter1d` (see section
+:ref:`ndimage-genericfilters`) accepts a callback function with the
following prototype:
The calling function iterates over the lines of the input and
output arrays, calling the callback function at each line. The
current line is extended according to the border conditions set by
the calling function, and the result is copied into the array that
- is passed through the {input_line} array. The length of the input
- line (after extension) is passed through {input_length}. The
+ is passed through the *input_line* array. The length of the input
+ line (after extension) is passed through *input_length*. The
callback function should apply the 1D filter and store the result
- in the array passed through {output_line}. The length of the
- output line is passed through {output_length}.
+ in the array passed through *output_line*. The length of the
+ output line is passed through *output_length*.
-The function {geometric_transform} (see section
-:ref:`_ndimage_interpolation`) expects a function with the following
+The function :func:`geometric_transform` (see section
+:ref:`ndimage-interpolation`) expects a function with the following
prototype:
The calling function iterates over the elements of the output
array, calling the callback function at each element. The
coordinates of the current output element are passed through
- {output_coordinates}. The callback function must return the
+ *output_coordinates*. The callback function must return the
coordinates at which the input must be interpolated in
- {input_coordinates}. The rank of the input and output arrays are
- given by {input_rank} and {output_rank} respectively.
+ *input_coordinates*. The rank of the input and output arrays are
+ given by *input_rank* and *output_rank* respectively.
From scipy-svn at scipy.org Sat Dec 20 06:21:33 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 20 Dec 2008 05:21:33 -0600 (CST)
Subject: [Scipy-svn] r5282 - trunk/doc/source/tutorial
Message-ID: <20081220112133.BCB0EC7C042@scipy.org>
Author: david.warde-farley
Date: 2008-12-20 05:21:30 -0600 (Sat, 20 Dec 2008)
New Revision: 5282
Modified:
trunk/doc/source/tutorial/index.rst
trunk/doc/source/tutorial/ndimage.rst
Log:
Eliminated {} around True, False, and None; fixed obvious misspellings, and added ndimage to index.rst.
Modified: trunk/doc/source/tutorial/index.rst
===================================================================
--- trunk/doc/source/tutorial/index.rst 2008-12-20 11:05:15 UTC (rev 5281)
+++ trunk/doc/source/tutorial/index.rst 2008-12-20 11:21:30 UTC (rev 5282)
@@ -16,4 +16,4 @@
signal
linalg
stats
-
+ ndimage
Modified: trunk/doc/source/tutorial/ndimage.rst
===================================================================
--- trunk/doc/source/tutorial/ndimage.rst 2008-12-20 11:05:15 UTC (rev 5281)
+++ trunk/doc/source/tutorial/ndimage.rst 2008-12-20 11:21:30 UTC (rev 5282)
@@ -1,5 +1,5 @@
Multi-dimensional image processing (:mod:`ndimage`)
-=========================================================
+===================================================
.. moduleauthor:: Peter Verveer
@@ -326,8 +326,8 @@
{derivative2(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
It should calculate the second derivative along the dimension
- *axis*. If *output* is not {None} it should use that for the output
- and return {None}, otherwise it should return the result. *mode*,
+ *axis*. If *output* is not None it should use that for the output
+ and return None, otherwise it should return the result. *mode*,
*cval* have the usual meaning.
The *extra_arguments* and *extra_keywords* arguments can be used
@@ -409,8 +409,8 @@
{derivative(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
It should calculate the derivative along the dimension *axis*. If
- *output* is not {None} it should use that for the output and return
- {None}, otherwise it should return the result. *mode*, *cval* have
+ *output* is not None it should use that for the output and return
+ None, otherwise it should return the result. *mode*, *cval* have
the usual meaning.
The *extra_arguments* and *extra_keywords* arguments can be used
@@ -596,9 +596,9 @@
These functions iterate over the lines or elements starting at the
-last axis, i.e. the last index changest the fastest. This order of
-iteration is garantueed for the case that it is important to adapt
-the filter dependening on spatial location. Here is an example of
+last axis, i.e. the last index changes the fastest. This order of
+iteration is guaranteed for the case that it is important to adapt
+the filter depending on spatial location. Here is an example of
using a class that implements the filter and keeps track of the
current coordinates while iterating. It performs the same filter
operation as described above for :func:`generic_filter`, but
@@ -747,7 +747,7 @@
The interpolation functions described in section
:ref:`ndimage-interpolation` apply pre-filtering by calling
:func:`spline_filter`, but they can be instructed not to do this by
-setting the *prefilter* keyword equal to {False}. This is useful if
+setting the *prefilter* keyword equal to False. This is useful if
more than one interpolation operation is done on the same array. In
this case it is more efficient to do the pre-filtering only once
and use a prefiltered array as the input of the interpolation
@@ -1002,7 +1002,7 @@
dilations must be achieved with the iterated structure. The adapted
origin is simply obtained by multiplying with the number of
iterations. For convenience the :func:`iterate_structure` also returns
- the adapted origin if the *origin* parameter is not {None}:
+ the adapted origin if the *origin* parameter is not None:
::
@@ -1058,7 +1058,7 @@
logical *not* of the input with the second structure, followed by
the logical *and* of these two erosions. The origin parameters
control the placement of the structuring elements as described in
- section :ref:`ndimage-filter-functions`. If {origin2} equals {None} it
+ section :ref:`ndimage-filter-functions`. If {origin2} equals None it
is set equal to the {origin1} parameter. If the first structuring
element is not provided, a structuring element with connectivity
equal to one is generated using :func:`generate_binary_structure`, if
@@ -1464,7 +1464,7 @@
:func:`find_objects` returns slices for all objects, unless the
*max_label* parameter is larger then zero, in which case only the
first *max_label* objects are returned. If an index is missing in
- the *label* array, {None} is return instead of a slice. For
+ the *label* array, None is return instead of a slice. For
example:
::
@@ -1524,7 +1524,7 @@
The measurement functions described below all support the *index*
parameter to indicate which object(s) should be measured. The
-default value of *index* is {None}. This indicates that all
+default value of *index* is None. This indicates that all
elements where the label is larger than zero should be treated as a
single object and measured. Thus, in this case the *labels* array
is treated as a mask defined by the elements that are larger than
@@ -1536,70 +1536,70 @@
The :func:`sum` function calculates the sum of the elements of the object
with label(s) given by *index*, using the *labels* array for the
- object labels. If *index* is {None}, all elements with a non-zero
- label value are treated as a single object. If *label* is {None},
+ object labels. If *index* is None, all elements with a non-zero
+ label value are treated as a single object. If *label* is None,
all elements of *input* are used in the calculation.
The :func:`mean` function calculates the mean of the elements of the
object with label(s) given by *index*, using the *labels* array for
- the object labels. If *index* is {None}, all elements with a
+ the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
- {None}, all elements of *input* are used in the calculation.
+ None, all elements of *input* are used in the calculation.
The :func:`variance` function calculates the variance of the elements of
the object with label(s) given by *index*, using the *labels* array
- for the object labels. If *index* is {None}, all elements with a
+ for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
- {None}, all elements of *input* are used in the calculation.
+ None, all elements of *input* are used in the calculation.
The :func:`standard_deviation` function calculates the standard
deviation of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
- is {None}, all elements with a non-zero label value are treated as
- a single object. If *label* is {None}, all elements of *input* are
+ is None, all elements with a non-zero label value are treated as
+ a single object. If *label* is None, all elements of *input* are
used in the calculation.
The :func:`minimum` function calculates the minimum of the elements of
the object with label(s) given by *index*, using the *labels* array
- for the object labels. If *index* is {None}, all elements with a
+ for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
- {None}, all elements of *input* are used in the calculation.
+ None, all elements of *input* are used in the calculation.
The :func:`maximum` function calculates the maximum of the elements of
the object with label(s) given by *index*, using the *labels* array
- for the object labels. If *index* is {None}, all elements with a
+ for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
- {None}, all elements of *input* are used in the calculation.
+ None, all elements of *input* are used in the calculation.
The :func:`minimum_position` function calculates the position of the
minimum of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
- is {None}, all elements with a non-zero label value are treated as
- a single object. If *label* is {None}, all elements of *input* are
+ is None, all elements with a non-zero label value are treated as
+ a single object. If *label* is None, all elements of *input* are
used in the calculation.
The :func:`maximum_position` function calculates the position of the
maximum of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
- is {None}, all elements with a non-zero label value are treated as
- a single object. If *label* is {None}, all elements of *input* are
+ is None, all elements with a non-zero label value are treated as
+ a single object. If *label* is None, all elements of *input* are
used in the calculation.
The :func:`extrema` function calculates the minimum, the maximum, and
their positions, of the elements of the object with label(s) given
by *index*, using the *labels* array for the object labels. If
- *index* is {None}, all elements with a non-zero label value are
- treated as a single object. If *label* is {None}, all elements of
+ *index* is None, all elements with a non-zero label value are
+ treated as a single object. If *label* is None, all elements of
*input* are used in the calculation. The result is a tuple giving
- the minimum, the maximum, the position of the mininum and the
+ the minimum, the maximum, the position of the minimum and the
postition of the maximum. The result is the same as a tuple formed
by the results of the functions *minimum*, *maximum*,
*minimum_position*, and *maximum_position* that are described
@@ -1608,17 +1608,17 @@
The :func:`center_of_mass` function calculates the center of mass of
the of the object with label(s) given by *index*, using the
- *labels* array for the object labels. If *index* is {None}, all
+ *labels* array for the object labels. If *index* is None, all
elements with a non-zero label value are treated as a single
- object. If *label* is {None}, all elements of *input* are used in
+ object. If *label* is None, all elements of *input* are used in
the calculation.
The :func:`histogram` function calculates a histogram of the of the
object with label(s) given by *index*, using the *labels* array for
- the object labels. If *index* is {None}, all elements with a
+ the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
- {None}, all elements of *input* are used in the calculation.
+ None, all elements of *input* are used in the calculation.
Histograms are defined by their minimum (*min*), maximum (*max*)
and the number of bins (*bins*). They are returned as
one-dimensional arrays of type Int32.
From scipy-svn at scipy.org Sat Dec 20 06:53:53 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 20 Dec 2008 05:53:53 -0600 (CST)
Subject: [Scipy-svn] r5283 - trunk/doc/source/tutorial
Message-ID: <20081220115353.AD3A0C7C026@scipy.org>
Author: david.warde-farley
Date: 2008-12-20 05:53:50 -0600 (Sat, 20 Dec 2008)
New Revision: 5283
Modified:
trunk/doc/source/tutorial/ndimage.rst
Log:
Yet more markup cleanup, :obj: is now used where functions are introduced and currentmodule:: has been introduced so as to enable cross-references to generated docs.
Modified: trunk/doc/source/tutorial/ndimage.rst
===================================================================
--- trunk/doc/source/tutorial/ndimage.rst 2008-12-20 11:21:30 UTC (rev 5282)
+++ trunk/doc/source/tutorial/ndimage.rst 2008-12-20 11:53:50 UTC (rev 5283)
@@ -5,7 +5,6 @@
.. currentmodule:: scipy.ndimage
-
.. _ndimage-introduction:
Introduction
@@ -58,6 +57,8 @@
Filter functions
----------------
+.. currentmodule:: scipy.ndimage.filters
+
The functions described in this section all perform some type of spatial filtering of the the input array: the elements in the output are some function of the values in the neighborhood of the corresponding input element. We refer to this neighborhood of elements as the filter kernel, which is often
rectangular in shape but may also have an arbitrary footprint. Many
of the functions described below allow you to define the footprint
@@ -139,7 +140,7 @@
"constant" Use a constant value, default is 0.0 [1 2 3]->[0 1 2 3 0]
========== ==================================== ====================
-The {"constant"} mode is special since it needs an additional
+The "constant" mode is special since it needs an additional
parameter to specify the constant value that should be used.
{The easiest way to implement such boundary conditions would be to
@@ -152,17 +153,17 @@
Correlation and convolution
---------------------------
- The :func:`correlate1d` function calculates a one-dimensional correlation
+ The :obj:`correlate1d` function calculates a one-dimensional correlation
along the given axis. The lines of the array along the given axis
are correlated with the given *weights*. The *weights* parameter
must be a one-dimensional sequences of numbers.
- The function :func:`correlate` implements multi-dimensional correlation
+ The function :obj:`correlate` implements multi-dimensional correlation
of the input array with a given kernel.
- The :func:`convolve1d` function calculates a one-dimensional convolution
+ The :obj:`convolve1d` function calculates a one-dimensional convolution
along the given axis. The lines of the array along the given axis
are convoluted with the given *weights*. The *weights* parameter
must be a one-dimensional sequences of numbers.
@@ -172,7 +173,7 @@
in the case of a correlation: the result is shifted in the opposite
directions.}
- The function :func:`convolve` implements multi-dimensional convolution of
+ The function :obj:`convolve` implements multi-dimensional convolution of
the input array with a given kernel.
{A convolution is essentially a correlation after mirroring the
@@ -186,7 +187,7 @@
-----------------
- The :func:`gaussian_filter1d` function implements a one-dimensional
+ The :obj:`gaussian_filter1d` function implements a one-dimensional
Gaussian filter. The standard-deviation of the Gaussian filter is
passed through the parameter *sigma*. Setting *order* = 0 corresponds
to convolution with a Gaussian kernel. An order of 1, 2, or 3
@@ -195,7 +196,7 @@
implemented.
- The :func:`gaussian_filter` function implements a multi-dimensional
+ The :obj:`gaussian_filter` function implements a multi-dimensional
Gaussian filter. The standard-deviations of the Gaussian filter
along each axis are passed through the parameter *sigma* as a
sequence or numbers. If *sigma* is not a sequence but a single
@@ -216,11 +217,11 @@
prevented by specifying a more precise output type.}
- The :func:`uniform_filter1d` function calculates a one-dimensional
+ The :obj:`uniform_filter1d` function calculates a one-dimensional
uniform filter of the given *size* along the given axis.
- The :func:`uniform_filter` implements a multi-dimensional uniform
+ The :obj:`uniform_filter` implements a multi-dimensional uniform
filter. The sizes of the uniform filter are given for each axis as
a sequence of integers by the *size* parameter. If *size* is not a
sequence, but a single number, the sizes along all axis are assumed
@@ -238,15 +239,15 @@
Filters based on order statistics
---------------------------------
- The :func:`minimum_filter1d` function calculates a one-dimensional
+ The :obj:`minimum_filter1d` function calculates a one-dimensional
minimum filter of given *size* along the given axis.
- The :func:`maximum_filter1d` function calculates a one-dimensional
+ The :obj:`maximum_filter1d` function calculates a one-dimensional
maximum filter of given *size* along the given axis.
- The :func:`minimum_filter` function calculates a multi-dimensional
+ The :obj:`minimum_filter` function calculates a multi-dimensional
minimum filter. Either the sizes of a rectangular kernel or the
footprint of the kernel must be provided. The *size* parameter, if
provided, must be a sequence of sizes or a single number in which
@@ -255,7 +256,7 @@
shape of the kernel by its non-zero elements.
- The :func:`maximum_filter` function calculates a multi-dimensional
+ The :obj:`maximum_filter` function calculates a multi-dimensional
maximum filter. Either the sizes of a rectangular kernel or the
footprint of the kernel must be provided. The *size* parameter, if
provided, must be a sequence of sizes or a single number in which
@@ -264,8 +265,8 @@
shape of the kernel by its non-zero elements.
- The :func:`rank_filter` function calculates a multi-dimensional rank
- filter. The *rank* may be less then zero, i.e., *rank* =-1 indicates
+ The :obj:`rank_filter` function calculates a multi-dimensional rank
+ filter. The *rank* may be less then zero, i.e., *rank* = -1 indicates
the largest element. Either the sizes of a rectangular kernel or
the footprint of the kernel must be provided. The *size* parameter,
if provided, must be a sequence of sizes or a single number in
@@ -274,9 +275,9 @@
the shape of the kernel by its non-zero elements.
- The :func:`percentile_filter` function calculates a multi-dimensional
+ The :obj:`percentile_filter` function calculates a multi-dimensional
percentile filter. The *percentile* may be less then zero, i.e.,
- *percentile* =-20 equals *percentile* =80. Either the sizes of a
+ *percentile* = -20 equals *percentile* = 80. Either the sizes of a
rectangular kernel or the footprint of the kernel must be provided.
The *size* parameter, if provided, must be a sequence of sizes or a
single number in which case the size of the filter is assumed to be
@@ -285,7 +286,7 @@
elements.
- The :func:`median_filter` function calculates a multi-dimensional median
+ The :obj:`median_filter` function calculates a multi-dimensional median
filter. Either the sizes of a rectangular kernel or the footprint
of the kernel must be provided. The *size* parameter, if provided,
must be a sequence of sizes or a single number in which case the
@@ -298,16 +299,16 @@
-----------
Derivative filters can be constructed in several ways. The function
-{gaussian_filter1d} described in section
+:func:`gaussian_filter1d` described in section
:ref:`ndimage-filter-functions-smoothing` can be used to calculate
derivatives along a given axis using the *order* parameter. Other
derivative filters are the Prewitt and Sobel filters:
- The :func:`prewitt` function calculates a derivative along the given
+ The :obj:`prewitt` function calculates a derivative along the given
axis.
- The :func:`sobel` function calculates a derivative along the given
+ The :obj:`sobel` function calculates a derivative along the given
axis.
@@ -318,13 +319,17 @@
calculate the second derivative along a given direction and to
construct the Laplace filter:
- The function :func:`generic_laplace` calculates a laplace filter using
+ The function :obj:`generic_laplace` calculates a laplace filter using
the function passed through :func:`derivative2` to calculate second
derivatives. The function :func:`derivative2` should have the following
signature:
- {derivative2(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
+ ::
+ derivative2(input, axis, output, mode, cval, *extra_arguments, **extra_keywords)
+
+
+
It should calculate the second derivative along the dimension
*axis*. If *output* is not None it should use that for the output
and return None, otherwise it should return the result. *mode*,
@@ -383,12 +388,12 @@
:func:`generic_laplace` by providing appropriate functions for the
second derivative function:
- The function :func:`laplace` calculates the Laplace using discrete
+ The function :obj:`laplace` calculates the Laplace using discrete
differentiation for the second derivative (i.e. convolution with
{[1, -2, 1]}).
- The function :func:`gaussian_laplace` calculates the Laplace using
+ The function :obj:`gaussian_laplace` calculates the Laplace using
:func:`gaussian_filter` to calculate the second derivatives. The
standard-deviations of the Gaussian filter along each axis are
passed through the parameter *sigma* as a sequence or numbers. If
@@ -401,13 +406,16 @@
generic Laplace function there is a :func:`generic_gradient_magnitude`
function that calculated the gradient magnitude of an array:
- The function :func:`generic_gradient_magnitude` calculates a gradient
+ The function :obj:`generic_gradient_magnitude` calculates a gradient
magnitude using the function passed through :func:`derivative` to
- calculate first derivatives. The function :func:`derivative` should have
+ calculate first derivatives. The function :obj:`derivative` should have
the following signature:
- {derivative(input, axis, output, mode, cval, \*extra_arguments, \*\*extra_keywords)}
+ ::
+ derivative(input, axis, output, mode, cval, *extra_arguments, **extra_keywords)
+
+
It should calculate the derivative along the dimension *axis*. If
*output* is not None it should use that for the output and return
None, otherwise it should return the result. *mode*, *cval* have
@@ -434,12 +442,12 @@
the *extra_arguments* and *extra_keywords* arguments.
-The :func:`sobel` and :func:`prewitt` functions fit the required signature and
+The :obj:`sobel` and :func:`prewitt` functions fit the required signature and
can therefore directly be used with :func:`generic_gradient_magnitude`.
The following function implements the gradient magnitude using
Gaussian derivatives:
- The function :func:`gaussian_gradient_magnitude` calculates the
+ The function :obj:`gaussian_gradient_magnitude` calculates the
gradient magnitude using :func:`gaussian_filter` to calculate the first
derivatives. The standard-deviations of the Gaussian filter along
each axis are passed through the parameter *sigma* as a sequence or
@@ -461,10 +469,10 @@
also be written in C and passed using a CObject (see
:ref:`ndimage-ccallbacks` for more information).
- The :func:`generic_filter1d` function implements a generic
+ The :obj:`generic_filter1d` function implements a generic
one-dimensional filter function, where the actual filtering
operation must be supplied as a python function (or other callable
- object). The :func:`generic_filter1d` function iterates over the lines
+ object). The :obj:`generic_filter1d` function iterates over the lines
of an array and calls :func:`function` at each line. The arguments that
are passed to :func:`function` are one-dimensional arrays of the
{tFloat64} type. The first contains the values of the current line.
@@ -525,9 +533,9 @@
[51 56 62 65]]
- The :func:`generic_filter` function implements a generic filter
+ The :obj:`generic_filter` function implements a generic filter
function, where the actual filtering operation must be supplied as
- a python function (or other callable object). The :func:`generic_filter`
+ a python function (or other callable object). The :obj:`generic_filter`
function iterates over the array and calls :func:`function` at each
element. The argument of :func:`function` is a one-dimensional array of
the {tFloat64} type, that contains the values around the current
@@ -708,26 +716,26 @@
transform. The parameter *axis* can be used to indicate along which
axis the real transform was executed.
- The :func:`fourier_shift` function multiplies the input array with the
+ The :obj:`fourier_shift` function multiplies the input array with the
multi-dimensional Fourier transform of a shift operation for the
given shift. The *shift* parameter is a sequences of shifts for
each dimension, or a single value for all dimensions.
- The :func:`fourier_gaussian` function multiplies the input array with
+ The :obj:`fourier_gaussian` function multiplies the input array with
the multi-dimensional Fourier transform of a Gaussian filter with
given standard-deviations *sigma*. The *sigma* parameter is a
sequences of values for each dimension, or a single value for all
dimensions.
- The :func:`fourier_uniform` function multiplies the input array with the
+ The :obj:`fourier_uniform` function multiplies the input array with the
multi-dimensional Fourier transform of a uniform filter with given
sizes *size*. The *size* parameter is a sequences of values for
each dimension, or a single value for all dimensions.
- The :func:`fourier_ellipsoid` function multiplies the input array with
+ The :obj:`fourier_ellipsoid` function multiplies the input array with
the multi-dimensional Fourier transform of a elliptically shaped
filter with given sizes *size*. The *size* parameter is a sequences
of values for each dimension, or a single value for all dimensions.
@@ -735,9 +743,14 @@
only implemented for dimensions 1, 2, and 3.}
+.. _ndimage-interpolation:
+
Interpolation functions
-----------------------
+.. currentmodule:: scipy.ndimage.interpolation
+
+
This section describes various interpolation functions that are
based on B-spline theory. A good introduction to B-splines can be
found in: M. Unser, "Splines: A Perfect Fit for Signal and Image
@@ -754,13 +767,13 @@
functions. The following two functions implement the
pre-filtering:
- The :func:`spline_filter1d` function calculates a one-dimensional spline
+ The :obj:`spline_filter1d` function calculates a one-dimensional spline
filter along the given axis. An output array can optionally be
provided. The order of the spline must be larger then 1 and less
than 6.
- The :func:`spline_filter` function calculates a multi-dimensional spline
+ The :obj:`spline_filter` function calculates a multi-dimensional spline
filter.
{The multi-dimensional filter is implemented as a sequence of
@@ -771,8 +784,6 @@
This can be prevented by specifying a output type of high precision.}
-.. _ndimage-interpolation:
-
Interpolation functions
-----------------------
@@ -786,7 +797,7 @@
a *cval* parameter that gives a constant value in case that the {'constant'}
mode is used.
- The :func:`geometric_transform` function applies an arbitrary geometric
+ The :obj:`geometric_transform` function applies an arbitrary geometric
transform to the input. The given *mapping* function is called at
each point in the output to find the corresponding coordinates in
the input. *mapping* must be a callable object that accepts a tuple
@@ -840,7 +851,7 @@
{The mapping function can also be written in C and passed using a CObject. See :ref:`ndimage-ccallbacks` for more information.}
- The function :func:`map_coordinates` applies an arbitrary coordinate
+ The function :obj:`map_coordinates` applies an arbitrary coordinate
transformation using the given array of coordinates. The shape of
the output is derived from that of the coordinate array by dropping
the first axis. The parameter *coordinates* is used to find for
@@ -865,7 +876,7 @@
[ 1.3625 7. ]
- The :func:`affine_transform` function applies an affine transformation
+ The :obj:`affine_transform` function applies an affine transformation
to the input array. The given transformation *matrix* and *offset*
are used to find for each point in the output the corresponding
coordinates in the input. The value of the input at the calculated
@@ -879,15 +890,15 @@
shape and type.
- The :func:`shift` function returns a shifted version of the input, using
+ The :obj:`shift` function returns a shifted version of the input, using
spline interpolation of the requested *order*.
- The :func:`zoom` function returns a rescaled version of the input, using
+ The :obj:`zoom` function returns a rescaled version of the input, using
spline interpolation of the requested *order*.
- The :func:`rotate` function returns the input array rotated in the plane
+ The :obj:`rotate` function returns the input array rotated in the plane
defined by the two axes given by the parameter *axes*, using spline
interpolation of the requested *order*. The angle must be given in
degrees. If *reshape* is true, then the size of the output array is
@@ -899,7 +910,7 @@
Binary morphology
-----------------
- The :func:`generate_binary_structure` functions generates a binary
+ The :obj:`generate_binary_structure` functions generates a binary
structuring element for use in binary morphology operations. The
*rank* of the structure must be provided. The size of the structure
that is returned is equal to three in each direction. The value of
@@ -923,7 +934,7 @@
Most binary morphology functions can be expressed in terms of the
basic operations erosion and dilation:
- The :func:`binary_erosion` function implements binary erosion of arrays
+ The :obj:`binary_erosion` function implements binary erosion of arrays
of arbitrary rank with the given structuring element. The origin
parameter controls the placement of the structuring element as
described in section :ref:`ndimage-filter-functions`. If no
@@ -937,7 +948,7 @@
are modified at each iteration.
- The :func:`binary_dilation` function implements binary dilation of
+ The :obj:`binary_dilation` function implements binary dilation of
arrays of arbitrary rank with the given structuring element. The
origin parameter controls the placement of the structuring element
as described in section :ref:`ndimage-filter-functions`. If no
@@ -970,15 +981,15 @@
[0 0 0 0 0]]
-The :func:`binary_erosion` and :func:`binary_dilation` functions both have an
+The :obj:`binary_erosion` and :func:`binary_dilation` functions both have an
*iterations* parameter which allows the erosion or dilation to be
repeated a number of times. Repeating an erosion or a dilation with
a given structure *n* times is equivalent to an erosion or a
-dilation with a structure that is {n-1} times dilated with itself.
+dilation with a structure that is *n-1* times dilated with itself.
A function is provided that allows the calculation of a structure
that is dilated a number of times with itself:
- The :func:`iterate_structure` function returns a structure by dilation
+ The :obj:`iterate_structure` function returns a structure by dilation
of the input structure *iteration* - 1 times with itself. For
instance:
@@ -1018,7 +1029,7 @@
d dilation. Following functions provide a few of these operations
for convenience:
- The :func:`binary_opening` function implements binary opening of arrays
+ The :obj:`binary_opening` function implements binary opening of arrays
of arbitrary rank with the given structuring element. Binary
opening is equivalent to a binary erosion followed by a binary
dilation with the same structuring element. The origin parameter
@@ -1030,7 +1041,7 @@
number of dilations.
- The :func:`binary_closing` function implements binary closing of arrays
+ The :obj:`binary_closing` function implements binary closing of arrays
of arbitrary rank with the given structuring element. Binary
closing is equivalent to a binary dilation followed by a binary
erosion with the same structuring element. The origin parameter
@@ -1042,7 +1053,7 @@
same number of erosions.
- The :func:`binary_fill_holes` function is used to close holes in
+ The :obj:`binary_fill_holes` function is used to close holes in
objects in a binary image, where the structure defines the
connectivity of the holes. The origin parameter controls the
placement of the structuring element as described in section
@@ -1051,19 +1062,19 @@
using :func:`generate_binary_structure`.
- The :func:`binary_hit_or_miss` function implements a binary
+ The :obj:`binary_hit_or_miss` function implements a binary
hit-or-miss transform of arrays of arbitrary rank with the given
structuring elements. The hit-or-miss transform is calculated by
erosion of the input with the first structure, erosion of the
logical *not* of the input with the second structure, followed by
the logical *and* of these two erosions. The origin parameters
control the placement of the structuring elements as described in
- section :ref:`ndimage-filter-functions`. If {origin2} equals None it
- is set equal to the {origin1} parameter. If the first structuring
+ section :ref:`ndimage-filter-functions`. If *origin2* equals None it
+ is set equal to the *origin1* parameter. If the first structuring
element is not provided, a structuring element with connectivity
equal to one is generated using :func:`generate_binary_structure`, if
- {structure2} is not provided, it is set equal to the logical *not*
- of {structure1}.
+ *structure2* is not provided, it is set equal to the logical *not*
+ of *structure1*.
.. _ndimage-grey-morphology:
@@ -1098,45 +1109,45 @@
Similar to binary erosion and dilation there are operations for
grey-scale erosion and dilation:
- The :func:`grey_erosion` function calculates a multi-dimensional grey-
+ The :obj:`grey_erosion` function calculates a multi-dimensional grey-
scale erosion.
- The :func:`grey_dilation` function calculates a multi-dimensional grey-
+ The :obj:`grey_dilation` function calculates a multi-dimensional grey-
scale dilation.
Grey-scale opening and closing operations can be defined similar to
their binary counterparts:
- The :func:`grey_opening` function implements grey-scale opening of
+ The :obj:`grey_opening` function implements grey-scale opening of
arrays of arbitrary rank. Grey-scale opening is equivalent to a
grey-scale erosion followed by a grey-scale dilation.
- The :func:`grey_closing` function implements grey-scale closing of
+ The :obj:`grey_closing` function implements grey-scale closing of
arrays of arbitrary rank. Grey-scale opening is equivalent to a
grey-scale dilation followed by a grey-scale erosion.
- The :func:`morphological_gradient` function implements a grey-scale
+ The :obj:`morphological_gradient` function implements a grey-scale
morphological gradient of arrays of arbitrary rank. The grey-scale
morphological gradient is equal to the difference of a grey-scale
dilation and a grey-scale erosion.
- The :func:`morphological_laplace` function implements a grey-scale
+ The :obj:`morphological_laplace` function implements a grey-scale
morphological laplace of arrays of arbitrary rank. The grey-scale
morphological laplace is equal to the sum of a grey-scale dilation
and a grey-scale erosion minus twice the input.
- The :func:`white_tophat` function implements a white top-hat filter of
+ The :obj:`white_tophat` function implements a white top-hat filter of
arrays of arbitrary rank. The white top-hat is equal to the
difference of the input and a grey-scale opening.
- The :func:`black_tophat` function implements a black top-hat filter of
+ The :obj:`black_tophat` function implements a black top-hat filter of
arrays of arbitrary rank. The black top-hat is equal to the
difference of the a grey-scale closing and the input.
@@ -1146,13 +1157,15 @@
Distance transforms
-------------------
+.. currentmodule:: scipy.ndimage.morphology
+
Distance transforms are used to
calculate the minimum distance from each element of an object to
the background. The following functions implement distance
transforms for three different distance metrics: Euclidean, City
Block, and Chessboard distances.
- The function :func:`distance_transform_cdt` uses a chamfer type
+ The function :obj:`distance_transform_cdt` uses a chamfer type
algorithm to calculate the distance transform of the input, by
replacing each object element (defined by values larger than zero)
with the shortest distance to the background (all non-object
@@ -1182,7 +1195,7 @@
27:321-345, 1984.
- The function :func:`distance_transform_edt` calculates the exact
+ The function :obj:`distance_transform_edt` calculates the exact
euclidean distance transform of the input, by replacing each object
element (defined by values larger than zero) with the shortest
euclidean distance to the background (all non-object elements).
@@ -1209,12 +1222,12 @@
in arbitrary dimensions. IEEE Trans. PAMI 25, 265-270, 2003.
- The function :func:`distance_transform_bf` uses a brute-force algorithm
+ The function :obj:`distance_transform_bf` uses a brute-force algorithm
to calculate the distance transform of the input, by replacing each
object element (defined by values larger than zero) with the
shortest distance to the background (all non-object elements). The
- metric must be one of {"euclidean"}, {"cityblock"}, or
- {"chessboard"}.
+ metric must be one of "euclidean", "cityblock", or
+ "chessboard".
In addition to the distance transform, the feature transform can be
calculated. In this case the index of the closest background
@@ -1260,10 +1273,10 @@
[0 0 0 0 1 0]]
The result is a binary image, in which the individual objects still
-need to be identified and labeled. The function :func:`label` generates
+need to be identified and labeled. The function :obj:`label` generates
an array where each object is assigned a unique number:
- The :func:`label` function generates an array where the objects in the
+ The :obj:`label` function generates an array where the objects in the
input are labeled with an integer index. It returns a tuple
consisting of the array of object labels and the number of objects
found, unless the *output* parameter is given, in which case only
@@ -1323,13 +1336,13 @@
There is a large number of other approaches for segmentation, for
instance from an estimation of the borders of the objects that can
be obtained for instance by derivative filters. One such an
-approach is watershed segmentation. The function :func:`watershed_ift`
+approach is watershed segmentation. The function :obj:`watershed_ift`
generates an array where each object is assigned a unique label,
from an array that localizes the object borders, generated for
instance by a gradient magnitude filter. It uses an array
containing initial markers for the objects:
- The :func:`watershed_ift` function applies a watershed from markers
+ The :obj:`watershed_ift` function applies a watershed from markers
algorithm, using an Iterative Forest Transform, as described in: P.
Felkel, R. Wegenkittl, and M. Bruckschwaiger, "Implementation and
Complexity of the Watershed-from-Markers Algorithm Computed as a
@@ -1364,8 +1377,8 @@
[1 1 2 2 2 1 1]
[1 1 1 1 1 1 1]]
- Here two markers were used to designate an object (marker=2) and
- the background (marker=1). The order in which these are processed
+ Here two markers were used to designate an object (*marker* = 2) and
+ the background (*marker* = 1). The order in which these are processed
is arbitrary: moving the marker for the background to the lower
right corner of the array yields a different result:
@@ -1387,7 +1400,7 @@
[1 1 1 1 1 1 1]
[1 1 1 1 1 1 1]]
- The result is that the object (marker=2) is smaller because the
+ The result is that the object (*marker* = 2) is smaller because the
second marker was processed earlier. This may not be the desired
effect if the first marker was supposed to designate a background
object. Therefore :func:`watershed_ift` treats markers with a negative
@@ -1436,15 +1449,19 @@
of the input to \\constant{UInt8} and \\constant{UInt16}.}
+.. _ndimage-object-measurements:
+
Object measurements
-------------------
+.. currentmodule:: scipy.ndimage.measurements
+
Given an array of labeled objects, the properties of the individual
-objects can be measured. The :func:`find_objects` function can be used
+objects can be measured. The :obj:`find_objects` function can be used
to generate a list of slices that for each object, give the
smallest sub-array that fully contains the object:
- The :func:`find_objects` function finds all objects in a labeled array and
+ The :obj:`find_objects` function finds all objects in a labeled array and
returns a list of slices that correspond to the smallest regions in
the array that contains the object. For instance:
@@ -1534,28 +1551,28 @@
one result, return their result as a tuple if *index* is a single
number, or as a tuple of lists, if *index* is a sequence.
- The :func:`sum` function calculates the sum of the elements of the object
+ The :obj:`sum` function calculates the sum of the elements of the object
with label(s) given by *index*, using the *labels* array for the
object labels. If *index* is None, all elements with a non-zero
label value are treated as a single object. If *label* is None,
all elements of *input* are used in the calculation.
- The :func:`mean` function calculates the mean of the elements of the
+ The :obj:`mean` function calculates the mean of the elements of the
object with label(s) given by *index*, using the *labels* array for
the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :func:`variance` function calculates the variance of the elements of
+ The :obj:`variance` function calculates the variance of the elements of
the object with label(s) given by *index*, using the *labels* array
for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :func:`standard_deviation` function calculates the standard
+ The :obj:`standard_deviation` function calculates the standard
deviation of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
is None, all elements with a non-zero label value are treated as
@@ -1563,21 +1580,21 @@
used in the calculation.
- The :func:`minimum` function calculates the minimum of the elements of
+ The :obj:`minimum` function calculates the minimum of the elements of
the object with label(s) given by *index*, using the *labels* array
for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :func:`maximum` function calculates the maximum of the elements of
+ The :obj:`maximum` function calculates the maximum of the elements of
the object with label(s) given by *index*, using the *labels* array
for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :func:`minimum_position` function calculates the position of the
+ The :obj:`minimum_position` function calculates the position of the
minimum of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
is None, all elements with a non-zero label value are treated as
@@ -1585,7 +1602,7 @@
used in the calculation.
- The :func:`maximum_position` function calculates the position of the
+ The :obj:`maximum_position` function calculates the position of the
maximum of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
is None, all elements with a non-zero label value are treated as
@@ -1593,7 +1610,7 @@
used in the calculation.
- The :func:`extrema` function calculates the minimum, the maximum, and
+ The :obj:`extrema` function calculates the minimum, the maximum, and
their positions, of the elements of the object with label(s) given
by *index*, using the *labels* array for the object labels. If
*index* is None, all elements with a non-zero label value are
@@ -1606,7 +1623,7 @@
above.
- The :func:`center_of_mass` function calculates the center of mass of
+ The :obj:`center_of_mass` function calculates the center of mass of
the of the object with label(s) given by *index*, using the
*labels* array for the object labels. If *index* is None, all
elements with a non-zero label value are treated as a single
@@ -1614,7 +1631,7 @@
the calculation.
- The :func:`histogram` function calculates a histogram of the of the
+ The :obj:`histogram` function calculates a histogram of the of the
object with label(s) given by *index*, using the *labels* array for
the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
@@ -1626,10 +1643,10 @@
.. _ndimage-ccallbacks:
-Extending *ndimage* in C
--------------------------
+Extending :mod:`ndimage` in C
+-----------------------------
-{C callback functions} A few functions in the {numarray.ndimage} take a call-back argument. This can be a python function, but also a CObject containing a pointer to a C function. To use this feature, you must write your own C extension that defines the function, and define a python function that
+A few functions in the :mod:`scipy.ndimage` take a call-back argument. This can be a python function, but also a CObject containing a pointer to a C function. To use this feature, you must write your own C extension that defines the function, and define a python function that
returns a CObject containing a pointer to this function.
An example of a function that supports this is
@@ -1745,7 +1762,7 @@
Functions that support C callback functions
-------------------------------------------
-The :func:`ndimage` functions that support C callback functions are
+The :mod:`ndimage` functions that support C callback functions are
described here. Obviously, the prototype of the function that is
provided to these functions must match exactly that what they
expect. Therefore we give here the prototypes of the callback
@@ -1773,7 +1790,6 @@
calculated valued should be returned in the *return_value*
argument.
-
The function :func:`generic_filter1d` (see section
:ref:`ndimage-genericfilters`) accepts a callback function with the
following prototype:
@@ -1788,7 +1804,6 @@
in the array passed through *output_line*. The length of the
output line is passed through *output_length*.
-
The function :func:`geometric_transform` (see section
:ref:`ndimage-interpolation`) expects a function with the following
prototype:
From scipy-svn at scipy.org Sat Dec 20 08:50:25 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 20 Dec 2008 07:50:25 -0600 (CST)
Subject: [Scipy-svn] r5284 - trunk/doc/source/tutorial
Message-ID: <20081220135025.4D293C7C026@scipy.org>
Author: david.warde-farley
Date: 2008-12-20 07:50:20 -0600 (Sat, 20 Dec 2008)
New Revision: 5284
Modified:
trunk/doc/source/tutorial/ndimage.rst
Log:
* Cleared up my understanding of :obj: vs. :func:. :func: is the right thing to be using.
* Replaced numarray with numpy wherever possible (not in code, though)
* Demarcated notes, which were previously just {} enclosed due to markup loss
* Got subsubsections working.
* Highlighting C code, linking to the Python C API (Sphinx rocks)
* Fixed up more crossreferencing stuff...
* Fixed a few typos/language errors.
* Morphology sub-heading to encompass both Binary and Greyscale, as it was before.
* currentmodule directives so that things link like they're supposed to.
* Removed "section" from the backreferences as "see section " doesn't make much sense, only makes sense if there is a number.
Still needs to be verified for parts of the C API that I'm not familiar with,
changed over to new C types (Int32 for example, to whatever is in use now). Otherwise I think the import is complete!
Modified: trunk/doc/source/tutorial/ndimage.rst
===================================================================
--- trunk/doc/source/tutorial/ndimage.rst 2008-12-20 11:53:50 UTC (rev 5283)
+++ trunk/doc/source/tutorial/ndimage.rst 2008-12-20 13:50:20 UTC (rev 5284)
@@ -14,7 +14,7 @@
two-dimensional arrays of values. There are however a number of
fields where images of higher dimensionality must be analyzed. Good
examples of these are medical imaging and biological imaging.
-:mod:`numarray` is suited very well for this type of applications due
+:mod:`numpy` is suited very well for this type of applications due
its inherent multi-dimensional nature. The :mod:`scipy.ndimage`
packages provides a number of general image processing and analysis
functions that are designed to operate with arrays of arbitrary
@@ -41,7 +41,7 @@
equal to the type of the specified output argument. If no output
argument is given, it is still possible to specify what the result
of the output should be. This is done by simply assigning the
-desired numarray type object to the output argument. For example:
+desired `numpy` type object to the output argument. For example:
::
@@ -50,7 +50,7 @@
>>> print correlate(arange(10), [1, 2.5], output = Float64)
[ 0. 2.5 6. 9.5 13. 16.5 20. 23.5 27. 30.5]
-{In previous versions of :mod:`scipy.ndimage`, some functions accepted the *output_type* argument to achieve the same effect. This argument is still supported, but its use will generate an deprecation warning. In a future version all instances of this argument will be removed. The preferred way to specify an output type, is by using the *output* argument, either by specifying an output array of the desired type, or by specifying the type of the output that is to be returned.}
+.. note:: In previous versions of :mod:`scipy.ndimage`, some functions accepted the *output_type* argument to achieve the same effect. This argument is still supported, but its use will generate an deprecation warning. In a future version all instances of this argument will be removed. The preferred way to specify an output type, is by using the *output* argument, either by specifying an output array of the desired type, or by specifying the type of the output that is to be returned.
.. _ndimage-filter-functions:
@@ -143,51 +143,40 @@
The "constant" mode is special since it needs an additional
parameter to specify the constant value that should be used.
-{The easiest way to implement such boundary conditions would be to
-copy the data to a larger array and extend the data at the borders
-according to the boundary conditions. For large arrays and large filter
-kernels, this would be very memory consuming, and the functions described
-below therefore use a different approach that does not require allocating
-large temporary buffers.}
+.. note:: The easiest way to implement such boundary conditions would be to copy the data to a larger array and extend the data at the borders according to the boundary conditions. For large arrays and large filter kernels, this would be very memory consuming, and the functions described below therefore use a different approach that does not require allocating large temporary buffers.
Correlation and convolution
----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
- The :obj:`correlate1d` function calculates a one-dimensional correlation
+ The :func:`correlate1d` function calculates a one-dimensional correlation
along the given axis. The lines of the array along the given axis
are correlated with the given *weights*. The *weights* parameter
must be a one-dimensional sequences of numbers.
- The function :obj:`correlate` implements multi-dimensional correlation
+ The function :func:`correlate` implements multi-dimensional correlation
of the input array with a given kernel.
- The :obj:`convolve1d` function calculates a one-dimensional convolution
+ The :func:`convolve1d` function calculates a one-dimensional convolution
along the given axis. The lines of the array along the given axis
are convoluted with the given *weights*. The *weights* parameter
must be a one-dimensional sequences of numbers.
- {A convolution is essentially a correlation after mirroring the
- kernel. As a result, the *origin* parameter behaves differently than
- in the case of a correlation: the result is shifted in the opposite
- directions.}
+ .. note:: A convolution is essentially a correlation after mirroring the kernel. As a result, the *origin* parameter behaves differently than in the case of a correlation: the result is shifted in the opposite directions.
- The function :obj:`convolve` implements multi-dimensional convolution of
+ The function :func:`convolve` implements multi-dimensional convolution of
the input array with a given kernel.
- {A convolution is essentially a correlation after mirroring the
- kernel. As a result, the *origin* parameter behaves differently than
- in the case of a correlation: the results is shifted in the opposite
- direction.}
+ .. note:: A convolution is essentially a correlation after mirroring the kernel. As a result, the *origin* parameter behaves differently than in the case of a correlation: the results is shifted in the opposite direction.
.. _ndimage-filter-functions-smoothing:
Smoothing filters
------------------
+^^^^^^^^^^^^^^^^^
- The :obj:`gaussian_filter1d` function implements a one-dimensional
+ The :func:`gaussian_filter1d` function implements a one-dimensional
Gaussian filter. The standard-deviation of the Gaussian filter is
passed through the parameter *sigma*. Setting *order* = 0 corresponds
to convolution with a Gaussian kernel. An order of 1, 2, or 3
@@ -196,7 +185,7 @@
implemented.
- The :obj:`gaussian_filter` function implements a multi-dimensional
+ The :func:`gaussian_filter` function implements a multi-dimensional
Gaussian filter. The standard-deviations of the Gaussian filter
along each axis are passed through the parameter *sigma* as a
sequence or numbers. If *sigma* is not a sequence but a single
@@ -209,45 +198,34 @@
number, to specify the same order for all axes, or a sequence of
numbers to specify a different order for each axis.
- {The multi-dimensional filter is implemented as a sequence of
- one-dimensional Gaussian filters. The intermediate arrays are stored in
- the same data type as the output. Therefore, for output types with a
- lower precision, the results may be imprecise because intermediate
- results may be stored with insufficient precision. This can be
- prevented by specifying a more precise output type.}
+ .. note:: The multi-dimensional filter is implemented as a sequence of one-dimensional Gaussian filters. The intermediate arrays are stored in the same data type as the output. Therefore, for output types with a lower precision, the results may be imprecise because intermediate results may be stored with insufficient precision. This can be prevented by specifying a more precise output type.
- The :obj:`uniform_filter1d` function calculates a one-dimensional
+ The :func:`uniform_filter1d` function calculates a one-dimensional
uniform filter of the given *size* along the given axis.
- The :obj:`uniform_filter` implements a multi-dimensional uniform
+ The :func:`uniform_filter` implements a multi-dimensional uniform
filter. The sizes of the uniform filter are given for each axis as
a sequence of integers by the *size* parameter. If *size* is not a
sequence, but a single number, the sizes along all axis are assumed
to be equal.
- {The multi-dimensional filter is implemented as a sequence of
- one-dimensional uniform filters. The intermediate arrays are stored in
- the same data type as the output. Therefore, for output types with a
- lower precision, the results may be imprecise because intermediate
- results may be stored with insufficient precision. This can be
- prevented by specifying a
- more precise output type.}
+ .. note:: The multi-dimensional filter is implemented as a sequence of one-dimensional uniform filters. The intermediate arrays are stored in the same data type as the output. Therefore, for output types with a lower precision, the results may be imprecise because intermediate results may be stored with insufficient precision. This can be prevented by specifying a more precise output type.
Filters based on order statistics
----------------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- The :obj:`minimum_filter1d` function calculates a one-dimensional
+ The :func:`minimum_filter1d` function calculates a one-dimensional
minimum filter of given *size* along the given axis.
- The :obj:`maximum_filter1d` function calculates a one-dimensional
+ The :func:`maximum_filter1d` function calculates a one-dimensional
maximum filter of given *size* along the given axis.
- The :obj:`minimum_filter` function calculates a multi-dimensional
+ The :func:`minimum_filter` function calculates a multi-dimensional
minimum filter. Either the sizes of a rectangular kernel or the
footprint of the kernel must be provided. The *size* parameter, if
provided, must be a sequence of sizes or a single number in which
@@ -256,7 +234,7 @@
shape of the kernel by its non-zero elements.
- The :obj:`maximum_filter` function calculates a multi-dimensional
+ The :func:`maximum_filter` function calculates a multi-dimensional
maximum filter. Either the sizes of a rectangular kernel or the
footprint of the kernel must be provided. The *size* parameter, if
provided, must be a sequence of sizes or a single number in which
@@ -265,7 +243,7 @@
shape of the kernel by its non-zero elements.
- The :obj:`rank_filter` function calculates a multi-dimensional rank
+ The :func:`rank_filter` function calculates a multi-dimensional rank
filter. The *rank* may be less then zero, i.e., *rank* = -1 indicates
the largest element. Either the sizes of a rectangular kernel or
the footprint of the kernel must be provided. The *size* parameter,
@@ -275,7 +253,7 @@
the shape of the kernel by its non-zero elements.
- The :obj:`percentile_filter` function calculates a multi-dimensional
+ The :func:`percentile_filter` function calculates a multi-dimensional
percentile filter. The *percentile* may be less then zero, i.e.,
*percentile* = -20 equals *percentile* = 80. Either the sizes of a
rectangular kernel or the footprint of the kernel must be provided.
@@ -286,7 +264,7 @@
elements.
- The :obj:`median_filter` function calculates a multi-dimensional median
+ The :func:`median_filter` function calculates a multi-dimensional median
filter. Either the sizes of a rectangular kernel or the footprint
of the kernel must be provided. The *size* parameter, if provided,
must be a sequence of sizes or a single number in which case the
@@ -296,19 +274,19 @@
Derivatives
------------
+^^^^^^^^^^^
Derivative filters can be constructed in several ways. The function
-:func:`gaussian_filter1d` described in section
+:func:`gaussian_filter1d` described in
:ref:`ndimage-filter-functions-smoothing` can be used to calculate
derivatives along a given axis using the *order* parameter. Other
derivative filters are the Prewitt and Sobel filters:
- The :obj:`prewitt` function calculates a derivative along the given
+ The :func:`prewitt` function calculates a derivative along the given
axis.
- The :obj:`sobel` function calculates a derivative along the given
+ The :func:`sobel` function calculates a derivative along the given
axis.
@@ -319,7 +297,7 @@
calculate the second derivative along a given direction and to
construct the Laplace filter:
- The function :obj:`generic_laplace` calculates a laplace filter using
+ The function :func:`generic_laplace` calculates a laplace filter using
the function passed through :func:`derivative2` to calculate second
derivatives. The function :func:`derivative2` should have the following
signature:
@@ -388,12 +366,12 @@
:func:`generic_laplace` by providing appropriate functions for the
second derivative function:
- The function :obj:`laplace` calculates the Laplace using discrete
+ The function :func:`laplace` calculates the Laplace using discrete
differentiation for the second derivative (i.e. convolution with
- {[1, -2, 1]}).
+ :obj:`[1, -2, 1]`).
- The function :obj:`gaussian_laplace` calculates the Laplace using
+ The function :func:`gaussian_laplace` calculates the Laplace using
:func:`gaussian_filter` to calculate the second derivatives. The
standard-deviations of the Gaussian filter along each axis are
passed through the parameter *sigma* as a sequence or numbers. If
@@ -406,9 +384,9 @@
generic Laplace function there is a :func:`generic_gradient_magnitude`
function that calculated the gradient magnitude of an array:
- The function :obj:`generic_gradient_magnitude` calculates a gradient
+ The function :func:`generic_gradient_magnitude` calculates a gradient
magnitude using the function passed through :func:`derivative` to
- calculate first derivatives. The function :obj:`derivative` should have
+ calculate first derivatives. The function :func:`derivative` should have
the following signature:
::
@@ -442,12 +420,12 @@
the *extra_arguments* and *extra_keywords* arguments.
-The :obj:`sobel` and :func:`prewitt` functions fit the required signature and
+The :func:`sobel` and :func:`prewitt` functions fit the required signature and
can therefore directly be used with :func:`generic_gradient_magnitude`.
The following function implements the gradient magnitude using
Gaussian derivatives:
- The function :obj:`gaussian_gradient_magnitude` calculates the
+ The function :func:`gaussian_gradient_magnitude` calculates the
gradient magnitude using :func:`gaussian_filter` to calculate the first
derivatives. The standard-deviations of the Gaussian filter along
each axis are passed through the parameter *sigma* as a sequence or
@@ -458,7 +436,7 @@
.. _ndimage-genericfilters:
Generic filter functions
-------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^
To implement filter functions, generic functions can be used that accept a
callable object that implements the filtering operation. The iteration over the
@@ -466,16 +444,16 @@
details as the implementation of the boundary conditions. Only a
callable object implementing a callback function that does the
actual filtering work must be provided. The callback function can
-also be written in C and passed using a CObject (see
+also be written in C and passed using a :ctype:`PyCObject` (see
:ref:`ndimage-ccallbacks` for more information).
- The :obj:`generic_filter1d` function implements a generic
+ The :func:`generic_filter1d` function implements a generic
one-dimensional filter function, where the actual filtering
operation must be supplied as a python function (or other callable
- object). The :obj:`generic_filter1d` function iterates over the lines
+ object). The :func:`generic_filter1d` function iterates over the lines
of an array and calls :func:`function` at each line. The arguments that
are passed to :func:`function` are one-dimensional arrays of the
- {tFloat64} type. The first contains the values of the current line.
+ :ctype:`tFloat64` type. The first contains the values of the current line.
It is extended at the beginning end the end, according to the
*filter_size* and *origin* arguments. The second array should be
modified in-place to provide the output values of the line. For
@@ -533,12 +511,12 @@
[51 56 62 65]]
- The :obj:`generic_filter` function implements a generic filter
+ The :func:`generic_filter` function implements a generic filter
function, where the actual filtering operation must be supplied as
- a python function (or other callable object). The :obj:`generic_filter`
+ a python function (or other callable object). The :func:`generic_filter`
function iterates over the array and calls :func:`function` at each
element. The argument of :func:`function` is a one-dimensional array of
- the {tFloat64} type, that contains the values around the current
+ the :ctype:`tFloat64` type, that contains the values around the current
element that are within the footprint of the filter. The function
should return a single value that can be converted to a double
precision number. For example consider a correlation:
@@ -698,12 +676,12 @@
[51 56 62 65]]
Fourier domain filters
-----------------------
+^^^^^^^^^^^^^^^^^^^^^^
The functions described in this section perform filtering
operations in the Fourier domain. Thus, the input array of such a
function should be compatible with an inverse Fourier transform
-function, such as the functions from the {scipy.fft} module. We
+function, such as the functions from the :mod:`numpy.fft` module. We
therefore have to deal with arrays that may be the result of a real
or a complex Fourier transform. In the case of a real Fourier
transform only half of the of the symmetric complex transform is
@@ -716,31 +694,30 @@
transform. The parameter *axis* can be used to indicate along which
axis the real transform was executed.
- The :obj:`fourier_shift` function multiplies the input array with the
+ The :func:`fourier_shift` function multiplies the input array with the
multi-dimensional Fourier transform of a shift operation for the
given shift. The *shift* parameter is a sequences of shifts for
each dimension, or a single value for all dimensions.
- The :obj:`fourier_gaussian` function multiplies the input array with
+ The :func:`fourier_gaussian` function multiplies the input array with
the multi-dimensional Fourier transform of a Gaussian filter with
given standard-deviations *sigma*. The *sigma* parameter is a
sequences of values for each dimension, or a single value for all
dimensions.
- The :obj:`fourier_uniform` function multiplies the input array with the
+ The :func:`fourier_uniform` function multiplies the input array with the
multi-dimensional Fourier transform of a uniform filter with given
sizes *size*. The *size* parameter is a sequences of values for
each dimension, or a single value for all dimensions.
- The :obj:`fourier_ellipsoid` function multiplies the input array with
+ The :func:`fourier_ellipsoid` function multiplies the input array with
the multi-dimensional Fourier transform of a elliptically shaped
filter with given sizes *size*. The *size* parameter is a sequences
of values for each dimension, or a single value for all dimensions.
- {This function is
- only implemented for dimensions 1, 2, and 3.}
+ This function is only implemented for dimensions 1, 2, and 3.
.. _ndimage-interpolation:
@@ -755,7 +732,12 @@
based on B-spline theory. A good introduction to B-splines can be
found in: M. Unser, "Splines: A Perfect Fit for Signal and Image
Processing," IEEE Signal Processing Magazine, vol. 16, no. 6, pp.
-22-38, November 1999. {Spline pre-filters} Interpolation using
+22-38, November 1999.
+
+Spline pre-filters
+^^^^^^^^^^^^^^^^^^
+
+Interpolation using
splines of an order larger than 1 requires a pre- filtering step.
The interpolation functions described in section
:ref:`ndimage-interpolation` apply pre-filtering by calling
@@ -767,37 +749,32 @@
functions. The following two functions implement the
pre-filtering:
- The :obj:`spline_filter1d` function calculates a one-dimensional spline
+ The :func:`spline_filter1d` function calculates a one-dimensional spline
filter along the given axis. An output array can optionally be
provided. The order of the spline must be larger then 1 and less
than 6.
- The :obj:`spline_filter` function calculates a multi-dimensional spline
+ The :func:`spline_filter` function calculates a multi-dimensional spline
filter.
- {The multi-dimensional filter is implemented as a sequence of
- one-dimensional spline filters. The intermediate arrays are stored in
- the same data type as the output. Therefore, if an output
- with a limited precision is requested, the results may be imprecise
- because intermediate results may be stored with insufficient precision.
- This can be prevented by specifying a output type of high precision.}
+ .. note:: The multi-dimensional filter is implemented as a sequence of one-dimensional spline filters. The intermediate arrays are stored in the same data type as the output. Therefore, if an output with a limited precision is requested, the results may be imprecise because intermediate results may be stored with insufficient precision. This can be prevented by specifying a output type of high precision.
Interpolation functions
------------------------
+^^^^^^^^^^^^^^^^^^^^^^^
Following functions all employ spline interpolation to effect some type of
geometric transformation of the input array. This requires a mapping of the
output coordinates to the input coordinates, and therefore the possibility
arises that input values outside the boundaries are needed. This problem is
-solved in the same way as described in section :ref:`ndimage-filter-functions`
+solved in the same way as described in :ref:`ndimage-filter-functions`
for the multi-dimensional filter functions. Therefore these functions all
support a *mode* parameter that determines how the boundaries are handled, and
-a *cval* parameter that gives a constant value in case that the {'constant'}
+a *cval* parameter that gives a constant value in case that the 'constant'
mode is used.
- The :obj:`geometric_transform` function applies an arbitrary geometric
+ The :func:`geometric_transform` function applies an arbitrary geometric
transform to the input. The given *mapping* function is called at
each point in the output to find the corresponding coordinates in
the input. *mapping* must be a callable object that accepts a tuple
@@ -848,17 +825,17 @@
[ 0. 4.8125 6.1875]
[ 0. 8.2625 9.6375]]
- {The mapping function can also be written in C and passed using a CObject. See :ref:`ndimage-ccallbacks` for more information.}
+ .. note:: The mapping function can also be written in C and passed using a :ctype:`PyCObject`. See :ref:`ndimage-ccallbacks` for more information.
- The function :obj:`map_coordinates` applies an arbitrary coordinate
+ The function :func:`map_coordinates` applies an arbitrary coordinate
transformation using the given array of coordinates. The shape of
the output is derived from that of the coordinate array by dropping
the first axis. The parameter *coordinates* is used to find for
each point in the output the corresponding coordinates in the
input. The values of *coordinates* along the first axis are the
coordinates in the input array at which the output value is found.
- (See also the numarray *coordinates* function.) Since the
+ (See also the numarray `coordinates` function.) Since the
coordinates may be non- integer coordinates, the value of the input
at these coordinates is determined by spline interpolation of the
requested order. Here is an example that interpolates a 2D array at
@@ -876,7 +853,7 @@
[ 1.3625 7. ]
- The :obj:`affine_transform` function applies an affine transformation
+ The :func:`affine_transform` function applies an affine transformation
to the input array. The given transformation *matrix* and *offset*
are used to find for each point in the output the corresponding
coordinates in the input. The value of the input at the calculated
@@ -890,27 +867,36 @@
shape and type.
- The :obj:`shift` function returns a shifted version of the input, using
+ The :func:`shift` function returns a shifted version of the input, using
spline interpolation of the requested *order*.
- The :obj:`zoom` function returns a rescaled version of the input, using
+ The :func:`zoom` function returns a rescaled version of the input, using
spline interpolation of the requested *order*.
- The :obj:`rotate` function returns the input array rotated in the plane
+ The :func:`rotate` function returns the input array rotated in the plane
defined by the two axes given by the parameter *axes*, using spline
interpolation of the requested *order*. The angle must be given in
degrees. If *reshape* is true, then the size of the output array is
adapted to contain the rotated input.
+.. _ndimage-morphology:
+
+Morphology
+----------
+
.. _ndimage-binary-morphology:
Binary morphology
------------------
+^^^^^^^^^^^^^^^^^
- The :obj:`generate_binary_structure` functions generates a binary
+.. currentmodule:: scipy.ndimage.morphology
+
+Binary morphology (need something to put here).
+
+ The :func:`generate_binary_structure` functions generates a binary
structuring element for use in binary morphology operations. The
*rank* of the structure must be provided. The size of the structure
that is returned is equal to three in each direction. The value of
@@ -934,10 +920,10 @@
Most binary morphology functions can be expressed in terms of the
basic operations erosion and dilation:
- The :obj:`binary_erosion` function implements binary erosion of arrays
+ The :func:`binary_erosion` function implements binary erosion of arrays
of arbitrary rank with the given structuring element. The origin
parameter controls the placement of the structuring element as
- described in section :ref:`ndimage-filter-functions`. If no
+ described in :ref:`ndimage-filter-functions`. If no
structuring element is provided, an element with connectivity equal
to one is generated using :func:`generate_binary_structure`. The
*border_value* parameter gives the value of the array outside
@@ -948,10 +934,10 @@
are modified at each iteration.
- The :obj:`binary_dilation` function implements binary dilation of
+ The :func:`binary_dilation` function implements binary dilation of
arrays of arbitrary rank with the given structuring element. The
origin parameter controls the placement of the structuring element
- as described in section :ref:`ndimage-filter-functions`. If no
+ as described in :ref:`ndimage-filter-functions`. If no
structuring element is provided, an element with connectivity equal
to one is generated using :func:`generate_binary_structure`. The
*border_value* parameter gives the value of the array outside
@@ -981,7 +967,7 @@
[0 0 0 0 0]]
-The :obj:`binary_erosion` and :func:`binary_dilation` functions both have an
+The :func:`binary_erosion` and :func:`binary_dilation` functions both have an
*iterations* parameter which allows the erosion or dilation to be
repeated a number of times. Repeating an erosion or a dilation with
a given structure *n* times is equivalent to an erosion or a
@@ -989,7 +975,7 @@
A function is provided that allows the calculation of a structure
that is dilated a number of times with itself:
- The :obj:`iterate_structure` function returns a structure by dilation
+ The :func:`iterate_structure` function returns a structure by dilation
of the input structure *iteration* - 1 times with itself. For
instance:
@@ -1029,47 +1015,47 @@
d dilation. Following functions provide a few of these operations
for convenience:
- The :obj:`binary_opening` function implements binary opening of arrays
+ The :func:`binary_opening` function implements binary opening of arrays
of arbitrary rank with the given structuring element. Binary
opening is equivalent to a binary erosion followed by a binary
dilation with the same structuring element. The origin parameter
controls the placement of the structuring element as described in
- section :ref:`ndimage-filter-functions`. If no structuring element is
+ :ref:`ndimage-filter-functions`. If no structuring element is
provided, an element with connectivity equal to one is generated
using :func:`generate_binary_structure`. The *iterations* parameter
gives the number of erosions that is performed followed by the same
number of dilations.
- The :obj:`binary_closing` function implements binary closing of arrays
+ The :func:`binary_closing` function implements binary closing of arrays
of arbitrary rank with the given structuring element. Binary
closing is equivalent to a binary dilation followed by a binary
erosion with the same structuring element. The origin parameter
controls the placement of the structuring element as described in
- section :ref:`ndimage-filter-functions`. If no structuring element is
+ :ref:`ndimage-filter-functions`. If no structuring element is
provided, an element with connectivity equal to one is generated
using :func:`generate_binary_structure`. The *iterations* parameter
gives the number of dilations that is performed followed by the
same number of erosions.
- The :obj:`binary_fill_holes` function is used to close holes in
+ The :func:`binary_fill_holes` function is used to close holes in
objects in a binary image, where the structure defines the
connectivity of the holes. The origin parameter controls the
- placement of the structuring element as described in section
+ placement of the structuring element as described in
:ref:`ndimage-filter-functions`. If no structuring element is
provided, an element with connectivity equal to one is generated
using :func:`generate_binary_structure`.
- The :obj:`binary_hit_or_miss` function implements a binary
+ The :func:`binary_hit_or_miss` function implements a binary
hit-or-miss transform of arrays of arbitrary rank with the given
structuring elements. The hit-or-miss transform is calculated by
erosion of the input with the first structure, erosion of the
logical *not* of the input with the second structure, followed by
the logical *and* of these two erosions. The origin parameters
control the placement of the structuring elements as described in
- section :ref:`ndimage-filter-functions`. If *origin2* equals None it
+ :ref:`ndimage-filter-functions`. If *origin2* equals None it
is set equal to the *origin1* parameter. If the first structuring
element is not provided, a structuring element with connectivity
equal to one is generated using :func:`generate_binary_structure`, if
@@ -1080,13 +1066,15 @@
.. _ndimage-grey-morphology:
Grey-scale morphology
----------------------
+^^^^^^^^^^^^^^^^^^^^^
+.. currentmodule:: scipy.ndimage.morphology
+
Grey-scale morphology operations are the equivalents of binary
morphology operations that operate on arrays with arbitrary values.
Below we describe the grey-scale equivalents of erosion, dilation,
opening and closing. These operations are implemented in a similar
-fashion as the filters described in section
+fashion as the filters described in
:ref:`ndimage-filter-functions`, and we refer to this section for the
description of filter kernels and footprints, and the handling of
array borders. The grey-scale morphology operations optionally take
@@ -1109,45 +1097,45 @@
Similar to binary erosion and dilation there are operations for
grey-scale erosion and dilation:
- The :obj:`grey_erosion` function calculates a multi-dimensional grey-
+ The :func:`grey_erosion` function calculates a multi-dimensional grey-
scale erosion.
- The :obj:`grey_dilation` function calculates a multi-dimensional grey-
+ The :func:`grey_dilation` function calculates a multi-dimensional grey-
scale dilation.
Grey-scale opening and closing operations can be defined similar to
their binary counterparts:
- The :obj:`grey_opening` function implements grey-scale opening of
+ The :func:`grey_opening` function implements grey-scale opening of
arrays of arbitrary rank. Grey-scale opening is equivalent to a
grey-scale erosion followed by a grey-scale dilation.
- The :obj:`grey_closing` function implements grey-scale closing of
+ The :func:`grey_closing` function implements grey-scale closing of
arrays of arbitrary rank. Grey-scale opening is equivalent to a
grey-scale dilation followed by a grey-scale erosion.
- The :obj:`morphological_gradient` function implements a grey-scale
+ The :func:`morphological_gradient` function implements a grey-scale
morphological gradient of arrays of arbitrary rank. The grey-scale
morphological gradient is equal to the difference of a grey-scale
dilation and a grey-scale erosion.
- The :obj:`morphological_laplace` function implements a grey-scale
+ The :func:`morphological_laplace` function implements a grey-scale
morphological laplace of arrays of arbitrary rank. The grey-scale
morphological laplace is equal to the sum of a grey-scale dilation
and a grey-scale erosion minus twice the input.
- The :obj:`white_tophat` function implements a white top-hat filter of
+ The :func:`white_tophat` function implements a white top-hat filter of
arrays of arbitrary rank. The white top-hat is equal to the
difference of the input and a grey-scale opening.
- The :obj:`black_tophat` function implements a black top-hat filter of
+ The :func:`black_tophat` function implements a black top-hat filter of
arrays of arbitrary rank. The black top-hat is equal to the
difference of the a grey-scale closing and the input.
@@ -1165,7 +1153,7 @@
transforms for three different distance metrics: Euclidean, City
Block, and Chessboard distances.
- The function :obj:`distance_transform_cdt` uses a chamfer type
+ The function :func:`distance_transform_cdt` uses a chamfer type
algorithm to calculate the distance transform of the input, by
replacing each object element (defined by values larger than zero)
with the shortest distance to the background (all non-object
@@ -1187,7 +1175,7 @@
The *distances* and *indices* arguments can be used to give
optional output arrays that must be of the correct size and type
- (both {Int32}).
+ (both :ctype:`Int32`).
The basics of the algorithm used to implement this function is
described in: G. Borgefors, "Distance transformations in arbitrary
@@ -1195,7 +1183,7 @@
27:321-345, 1984.
- The function :obj:`distance_transform_edt` calculates the exact
+ The function :func:`distance_transform_edt` calculates the exact
euclidean distance transform of the input, by replacing each object
element (defined by values larger than zero) with the shortest
euclidean distance to the background (all non-object elements).
@@ -1214,7 +1202,7 @@
The *distances* and *indices* arguments can be used to give
optional output arrays that must be of the correct size and type
- ({Float64} and {Int32}).
+ (:ctype:`Float64` and :ctype:`Int32`).
The algorithm used to implement this function is described in: C.
R. Maurer, Jr., R. Qi, and V. Raghavan, "A linear time algorithm
@@ -1222,7 +1210,7 @@
in arbitrary dimensions. IEEE Trans. PAMI 25, 265-270, 2003.
- The function :obj:`distance_transform_bf` uses a brute-force algorithm
+ The function :func:`distance_transform_bf` uses a brute-force algorithm
to calculate the distance transform of the input, by replacing each
object element (defined by values larger than zero) with the
shortest distance to the background (all non-object elements). The
@@ -1244,13 +1232,9 @@
The *distances* and *indices* arguments can be used to give
optional output arrays that must be of the correct size and type
- ({Float64} and {Int32}).
+ (:ctype:`Float64` and :ctype:`Int32`).
- {This function uses a slow brute-force algorithm, the function
- :func:`distance_transform_cdt` can be used to more efficiently
- calculate cityblock and chessboard distance transforms. The function
- :func:`distance_transform_edt` can be used to more efficiently
- calculate the exact euclidean distance transform.}
+ .. note:: This function uses a slow brute-force algorithm, the function :func:`distance_transform_cdt` can be used to more efficiently calculate cityblock and chessboard distance transforms. The function :func:`distance_transform_edt` can be used to more efficiently calculate the exact euclidean distance transform.
Segmentation and labeling
@@ -1273,10 +1257,10 @@
[0 0 0 0 1 0]]
The result is a binary image, in which the individual objects still
-need to be identified and labeled. The function :obj:`label` generates
+need to be identified and labeled. The function :func:`label` generates
an array where each object is assigned a unique number:
- The :obj:`label` function generates an array where the objects in the
+ The :func:`label` function generates an array where the objects in the
input are labeled with an integer index. It returns a tuple
consisting of the array of object labels and the number of objects
found, unless the *output* parameter is given, in which case only
@@ -1310,7 +1294,8 @@
[0 0 0 0 1 0]]
If no structuring element is provided, one is generated by calling
- *generate_binary_structure* (see section :ref:`ndimage-binary-morphology`)
+ :func:`generate_binary_structure` (see
+ :ref:`ndimage-binary-morphology`)
using a connectivity of one (which in 2D is the 4-connected
structure of the first example). The input can be of any type, any
value not equal to zero is taken to be part of an object. This is
@@ -1329,20 +1314,19 @@
>>> print label(l)[0]
[1 0 0 0 2]
- {The structuring element used by :func:`label` is assumed to be
- symmetric.}
+ .. note:: The structuring element used by :func:`label` is assumed to be symmetric.
There is a large number of other approaches for segmentation, for
instance from an estimation of the borders of the objects that can
be obtained for instance by derivative filters. One such an
-approach is watershed segmentation. The function :obj:`watershed_ift`
+approach is watershed segmentation. The function :func:`watershed_ift`
generates an array where each object is assigned a unique label,
from an array that localizes the object borders, generated for
instance by a gradient magnitude filter. It uses an array
containing initial markers for the objects:
- The :obj:`watershed_ift` function applies a watershed from markers
+ The :func:`watershed_ift` function applies a watershed from markers
algorithm, using an Iterative Forest Transform, as described in: P.
Felkel, R. Wegenkittl, and M. Bruckschwaiger, "Implementation and
Complexity of the Watershed-from-Markers Algorithm Computed as a
@@ -1428,7 +1412,7 @@
The connectivity of the objects is defined by a structuring
element. If no structuring element is provided, one is generated by
- calling :func:`generate_binary_structure` (see section
+ calling :func:`generate_binary_structure` (see
:ref:`ndimage-binary-morphology`) using a connectivity of one
(which in 2D is a 4-connected structure.) For example, using
an 8-connected structure with the last example yields a different object:
@@ -1445,8 +1429,7 @@
[-1 2 2 2 2 2 -1]
[-1 -1 -1 -1 -1 -1 -1]]
- {The implementation of :func:`watershed_ift` limits the data types
- of the input to \\constant{UInt8} and \\constant{UInt16}.}
+ .. note:: The implementation of :func:`watershed_ift` limits the data types of the input to :ctype:`UInt8` and :ctype:`UInt16`.
.. _ndimage-object-measurements:
@@ -1457,11 +1440,11 @@
.. currentmodule:: scipy.ndimage.measurements
Given an array of labeled objects, the properties of the individual
-objects can be measured. The :obj:`find_objects` function can be used
+objects can be measured. The :func:`find_objects` function can be used
to generate a list of slices that for each object, give the
smallest sub-array that fully contains the object:
- The :obj:`find_objects` function finds all objects in a labeled array and
+ The :func:`find_objects` function finds all objects in a labeled array and
returns a list of slices that correspond to the smallest regions in
the array that contains the object. For instance:
@@ -1551,28 +1534,28 @@
one result, return their result as a tuple if *index* is a single
number, or as a tuple of lists, if *index* is a sequence.
- The :obj:`sum` function calculates the sum of the elements of the object
+ The :func:`sum` function calculates the sum of the elements of the object
with label(s) given by *index*, using the *labels* array for the
object labels. If *index* is None, all elements with a non-zero
label value are treated as a single object. If *label* is None,
all elements of *input* are used in the calculation.
- The :obj:`mean` function calculates the mean of the elements of the
+ The :func:`mean` function calculates the mean of the elements of the
object with label(s) given by *index*, using the *labels* array for
the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :obj:`variance` function calculates the variance of the elements of
+ The :func:`variance` function calculates the variance of the elements of
the object with label(s) given by *index*, using the *labels* array
for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :obj:`standard_deviation` function calculates the standard
+ The :func:`standard_deviation` function calculates the standard
deviation of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
is None, all elements with a non-zero label value are treated as
@@ -1580,21 +1563,21 @@
used in the calculation.
- The :obj:`minimum` function calculates the minimum of the elements of
+ The :func:`minimum` function calculates the minimum of the elements of
the object with label(s) given by *index*, using the *labels* array
for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :obj:`maximum` function calculates the maximum of the elements of
+ The :func:`maximum` function calculates the maximum of the elements of
the object with label(s) given by *index*, using the *labels* array
for the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
- The :obj:`minimum_position` function calculates the position of the
+ The :func:`minimum_position` function calculates the position of the
minimum of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
is None, all elements with a non-zero label value are treated as
@@ -1602,7 +1585,7 @@
used in the calculation.
- The :obj:`maximum_position` function calculates the position of the
+ The :func:`maximum_position` function calculates the position of the
maximum of the elements of the object with label(s) given by
*index*, using the *labels* array for the object labels. If *index*
is None, all elements with a non-zero label value are treated as
@@ -1610,7 +1593,7 @@
used in the calculation.
- The :obj:`extrema` function calculates the minimum, the maximum, and
+ The :func:`extrema` function calculates the minimum, the maximum, and
their positions, of the elements of the object with label(s) given
by *index*, using the *labels* array for the object labels. If
*index* is None, all elements with a non-zero label value are
@@ -1623,7 +1606,7 @@
above.
- The :obj:`center_of_mass` function calculates the center of mass of
+ The :func:`center_of_mass` function calculates the center of mass of
the of the object with label(s) given by *index*, using the
*labels* array for the object labels. If *index* is None, all
elements with a non-zero label value are treated as a single
@@ -1631,14 +1614,14 @@
the calculation.
- The :obj:`histogram` function calculates a histogram of the of the
+ The :func:`histogram` function calculates a histogram of the of the
object with label(s) given by *index*, using the *labels* array for
the object labels. If *index* is None, all elements with a
non-zero label value are treated as a single object. If *label* is
None, all elements of *input* are used in the calculation.
Histograms are defined by their minimum (*min*), maximum (*max*)
and the number of bins (*bins*). They are returned as
- one-dimensional arrays of type Int32.
+ one-dimensional arrays of type :ctype:`Int32`.
.. _ndimage-ccallbacks:
@@ -1646,11 +1629,15 @@
Extending :mod:`ndimage` in C
-----------------------------
-A few functions in the :mod:`scipy.ndimage` take a call-back argument. This can be a python function, but also a CObject containing a pointer to a C function. To use this feature, you must write your own C extension that defines the function, and define a python function that
-returns a CObject containing a pointer to this function.
+.. highlight:: c
+A few functions in the :mod:`scipy.ndimage` take a call-back
+argument. This can be a python function, but also a :ctype:`PyCObject`
+containing a pointer to a C function. To use this feature, you must
+write your own C extension that defines the function, and define a Python function that returns a :ctype:`PyCObject` containing a pointer to this function.
+
An example of a function that supports this is
-:func:`geometric_transform` (see section :ref:`ndimage-interpolation`).
+:func:`geometric_transform` (see :ref:`ndimage-interpolation`).
You can pass it a python callable object that defines a mapping
from all output coordinates to corresponding coordinates in the
input array. This mapping function can also be a C function, which
@@ -1688,7 +1675,7 @@
A pointer to this function and a pointer to the shift value must be
passed to :func:`geometric_transform`. Both are passed by a single
-CObject which is created by the following python extension
+:ctype:`PyCObject` which is created by the following python extension
function:
::
@@ -1712,10 +1699,10 @@
The value of the shift is obtained and then assigned to a
dynamically allocated memory location. Both this data pointer and
-the function pointer are then wrapped in a CObject, which is
+the function pointer are then wrapped in a :ctype:`PyCObject`, which is
returned. Additionally, a pointer to a destructor function is
given, that will free the memory we allocated for the shift value
-when the CObject is destroyed. This destructor is very simple:
+when the :ctype:`PyCObject` is destroyed. This destructor is very simple:
::
@@ -1726,7 +1713,7 @@
free(cdata);
}
-To use these functions, an extension module is build:
+To use these functions, an extension module is built:
::
@@ -1743,6 +1730,8 @@
This extension can then be used in Python, for example:
+.. highlight:: python
+
::
>>> import example
@@ -1754,7 +1743,7 @@
[ 0. 4.8125 6.1875]
[ 0. 8.2625 9.6375]]
-C Callback functions for use with :mod:`ndimage` functions must all
+C callback functions for use with :mod:`ndimage` functions must all
be written according to this scheme. The next section lists the
:mod:`ndimage` functions that acccept a C callback function and
gives the prototype of the callback function.
@@ -1767,18 +1756,18 @@
provided to these functions must match exactly that what they
expect. Therefore we give here the prototypes of the callback
functions. All these callback functions accept a void
-*callback_data* pointer that must be wrapped in a CObject using
-the Python {PyCObject_FromVoidPtrAndDesc} function, which can also
+*callback_data* pointer that must be wrapped in a :ctype:`PyCObject` using
+the Python :cfunc:`PyCObject_FromVoidPtrAndDesc` function, which can also
accept a pointer to a destructor function to free any memory
allocated for *callback_data*. If *callback_data* is not needed,
-{PyCObject_FromVoidPtr} may be used instead. The callback
+:cfunc:`PyCObject_FromVoidPtr` may be used instead. The callback
functions must return an integer error status that is equal to zero
if something went wrong, or 1 otherwise. If an error occurs, you
should normally set the python error status with an informative
message before returning, otherwise, a default error message is set
by the calling function.
-The function :func:`generic_filter` (see section
+The function :func:`generic_filter` (see
:ref:`ndimage-genericfilters`) accepts a callback function with the
following prototype:
@@ -1790,7 +1779,7 @@
calculated valued should be returned in the *return_value*
argument.
-The function :func:`generic_filter1d` (see section
+The function :func:`generic_filter1d` (see
:ref:`ndimage-genericfilters`) accepts a callback function with the
following prototype:
@@ -1804,7 +1793,7 @@
in the array passed through *output_line*. The length of the
output line is passed through *output_length*.
-The function :func:`geometric_transform` (see section
+The function :func:`geometric_transform` (see
:ref:`ndimage-interpolation`) expects a function with the following
prototype:
From scipy-svn at scipy.org Sun Dec 21 12:33:43 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sun, 21 Dec 2008 11:33:43 -0600 (CST)
Subject: [Scipy-svn] r5285 - in trunk/scipy/stats: . tests
Message-ID: <20081221173343.F0E27C7C07B@scipy.org>
Author: josef
Date: 2008-12-21 11:33:40 -0600 (Sun, 21 Dec 2008)
New Revision: 5285
Modified:
trunk/scipy/stats/stats.py
trunk/scipy/stats/tests/test_stats.py
Log:
cleaning up stats.ttests, add tests, tests and doctests pass, see http://projects.scipy.org/pipermail/scipy-dev/2008-December/010670.html
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-20 13:50:20 UTC (rev 5284)
+++ trunk/scipy/stats/stats.py 2008-12-21 17:33:40 UTC (rev 5285)
@@ -1870,23 +1870,33 @@
##### INFERENTIAL STATISTICS #####
#####################################
-def ttest_1samp(a, popmean):
+def ttest_1samp(a, popmean, axis=0):
"""
Calculates the t-obtained for the independent samples T-test on ONE group
of scores a, given a population mean.
Returns: t-value, two-tailed prob
"""
- a = asarray(a)
- x = np.mean(a)
- v = np.var(a, ddof=1)
- n = len(a)
- df = n-1
- svar = ((n-1)*v) / float(df)
- t = (x-popmean)/np.sqrt(svar*(1.0/n))
- #prob = betai(0.5*df,0.5,df/(df+t*t))
+
+
+ a, axis = _chk_asarray(a, axis)
+ n = a.shape[axis]
+ df=n-1
+
+ d = np.mean(a,axis) - popmean
+ v = np.var(a, axis, ddof=1)
+
+ t = d / np.sqrt(v/float(n))
+ t = np.where((d==0)*(v==0), 1.0, t) #define t=0/0 = 1, identical mean, var
prob = distributions.t.sf(np.abs(t),df)*2 #use np.abs to get upper tail
+ #distributions.t.sf currently does not propagate nans
+ #this can be dropped, if distributions.t.sf propagates nans
+ #if this is removed, then prob = prob[()] needs to be removed
+ prob = np.where(np.isnan(t), np.nan, prob)
+ if t.ndim == 0:
+ t = t[()]
+ prob = prob[()]
return t,prob
@@ -1928,38 +1938,44 @@
# test with sample with identical means
>>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500)
- >>> stats.ttest_ind(rvs1,rvs2)
- (array(0.26833823296239279), 0.78849443369564765)
+ >>> ttest_ind(rvs1,rvs2)
+ (0.26833823296239279, 0.78849443369564765)
# test with sample with different means
>>> rvs3 = stats.norm.rvs(loc=8,scale=10,size=500)
- >>> stats.ttest_ind(rvs1,rvs3)
- (array(-5.0434013458585092), 5.4302979468623391e-007)
+ >>> ttest_ind(rvs1,rvs3)
+ (-5.0434013458585092, 5.4302979468623391e-007)
"""
a, b, axis = _chk2_asarray(a, b, axis)
- x1 = mean(a,axis)
- x2 = mean(b,axis)
- v1 = var(a,axis)
- v2 = var(b,axis)
+
+ v1 = np.var(a,axis,ddof = 1)
+ v2 = np.var(b,axis,ddof = 1)
n1 = a.shape[axis]
n2 = b.shape[axis]
df = n1+n2-2
+
+ d = mean(a,axis) - mean(b,axis)
svar = ((n1-1)*v1+(n2-1)*v2) / float(df)
- zerodivproblem = svar == 0
- t = (x1-x2)/np.sqrt(svar*(1.0/n1 + 1.0/n2)) # N-D COMPUTATION HERE!!!!!!
- t = np.where(zerodivproblem, 1.0, t) # replace NaN t-values with 1.0
- probs = distributions.t.sf(np.abs(t),df)*2
- if not np.isscalar(t):
- probs = probs.reshape(t.shape)
- if not np.isscalar(probs) and len(probs) == 1:
- probs = probs[0]
- return t, probs
+ t = d/np.sqrt(svar*(1.0/n1 + 1.0/n2))
+ t = np.where((d==0)*(svar==0), 1.0, t) #define t=0/0 = 0, identical means
+ prob = distributions.t.sf(np.abs(t),df)*2#use np.abs to get upper tail
+
+ #distributions.t.sf currently does not propagate nans
+ #this can be dropped, if distributions.t.sf propagates nans
+ #if this is removed, then prob = prob[()] needs to be removed
+ prob = np.where(np.isnan(t), np.nan, prob)
+ if t.ndim == 0:
+ t = t[()]
+ prob = prob[()]
+
+ return t, prob
-def ttest_rel(a,b,axis=None):
+
+def ttest_rel(a,b,axis=0):
"""Calculates the t-obtained T-test on TWO RELATED samples of scores, a
and b. From Numerical Recipies, p.483. Axis can equal None (ravel array
first), or an integer (the axis over which to operate on a and b).
@@ -1987,8 +2003,6 @@
Examples
--------
- (note: after changes difference in 13th decimal)
-
>>> from scipy import stats
>>> import numpy as np
@@ -1998,35 +2012,40 @@
>>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500) + \
stats.norm.rvs(scale=0.2,size=500)
>>> stats.ttest_rel(rvs1,rvs2)
- (array(0.24101764965300965), 0.80964043445811562)
+ (0.24101764965300962, 0.80964043445811562)
>>> rvs3 = stats.norm.rvs(loc=8,scale=10,size=500) + \
stats.norm.rvs(scale=0.2,size=500)
>>> stats.ttest_rel(rvs1,rvs3)
- (array(-3.9995108708727929), 7.3082402191726459e-005)
+ (-3.9995108708727933, 7.3082402191726459e-005)
"""
a, b, axis = _chk2_asarray(a, b, axis)
- if len(a)!=len(b):
+ if a.shape[axis] != b.shape[axis]:
raise ValueError, 'unequal length arrays'
- x1 = mean(a,axis)
- x2 = mean(b,axis)
- v1 = var(a,axis)
- v2 = var(b,axis)
n = a.shape[axis]
df = float(n-1)
+
d = (a-b).astype('d')
+ v = np.var(d,axis,ddof=1)
+ dm = np.mean(d, axis)
+
+ t = dm / np.sqrt(v/float(n))
+ t = np.where((dm==0)*(v==0), 1.0, t) #define t=0/0 = 1, zero mean and var
+ prob = distributions.t.sf(np.abs(t),df)*2 #use np.abs to get upper tail
+ #distributions.t.sf currently does not propagate nans
+ #this can be dropped, if distributions.t.sf propagates nans
+ #if this is removed, then prob = prob[()] needs to be removed
+ prob = np.where(np.isnan(t), np.nan, prob)
+
+## if not np.isscalar(t):
+## probs = np.reshape(probs, t.shape) # this should be redundant
+## if not np.isscalar(prob) and len(prob) == 1:
+## prob = prob[0]
+ if t.ndim == 0:
+ t = t[()]
+ prob = prob[()]
- #denom is just sqrt(var(d)/df)
- denom = np.sqrt(np.var(d,axis,ddof=1)/float(n))
- zerodivproblem = denom == 0
- t = np.mean(d, axis) / denom
- t = np.where(zerodivproblem, 1.0, t) # replace NaN t-values with 1.0
- probs = distributions.t.sf(np.abs(t),df)*2
- if not np.isscalar(t):
- probs = np.reshape(probs, t.shape)
- if not np.isscalar(probs) and len(probs) == 1:
- probs = probs[0]
- return t, probs
+ return t, prob
#import scipy.stats
Modified: trunk/scipy/stats/tests/test_stats.py
===================================================================
--- trunk/scipy/stats/tests/test_stats.py 2008-12-20 13:50:20 UTC (rev 5284)
+++ trunk/scipy/stats/tests/test_stats.py 2008-12-21 17:33:40 UTC (rev 5285)
@@ -1071,7 +1071,110 @@
t,p = stats.ttest_rel(rvs1_2D, rvs2_2D, axis=1)
assert_array_almost_equal([t,p],tpr)
+ #test on 3 dimensions
+ rvs1_3D = np.dstack([rvs1_2D,rvs1_2D,rvs1_2D])
+ rvs2_3D = np.dstack([rvs2_2D,rvs2_2D,rvs2_2D])
+ t,p = stats.ttest_rel(rvs1_3D, rvs2_3D, axis=1)
+ assert_array_almost_equal(np.abs(t), tr)
+ assert_array_almost_equal(np.abs(p), pr)
+ assert_equal(t.shape, (2, 3))
+ t,p = stats.ttest_rel(np.rollaxis(rvs1_3D,2), np.rollaxis(rvs2_3D,2), axis=2)
+ assert_array_almost_equal(np.abs(t), tr)
+ assert_array_almost_equal(np.abs(p), pr)
+ assert_equal(t.shape, (3, 2))
+ #test zero division problem
+ t,p = stats.ttest_rel([0,0,0],[1,1,1])
+ assert_equal((np.abs(t),p), (np.inf, 0))
+ assert_equal(stats.ttest_rel([0,0,0], [0,0,0]), (1.0, 0.42264973081037427))
+
+ #check that nan in input array result in nan output
+ anan = np.array([[1,np.nan],[-1,1]])
+ assert_equal(stats.ttest_ind(anan, np.zeros((2,2))),([0, np.nan], [1,np.nan]))
+
+
+def test_ttest_ind():
+ #regression test
+ tr = 1.0912746897927283
+ pr = 0.27647818616351882
+ tpr = ([tr,-tr],[pr,pr])
+
+ rvs2 = np.linspace(1,100,100)
+ rvs1 = np.linspace(5,105,100)
+ rvs1_2D = np.array([rvs1, rvs2])
+ rvs2_2D = np.array([rvs2, rvs1])
+
+ t,p = stats.ttest_ind(rvs1, rvs2, axis=0)
+ assert_array_almost_equal([t,p],(tr,pr))
+ t,p = stats.ttest_ind(rvs1_2D.T, rvs2_2D.T, axis=0)
+ assert_array_almost_equal([t,p],tpr)
+ t,p = stats.ttest_ind(rvs1_2D, rvs2_2D, axis=1)
+ assert_array_almost_equal([t,p],tpr)
+
+ #test on 3 dimensions
+ rvs1_3D = np.dstack([rvs1_2D,rvs1_2D,rvs1_2D])
+ rvs2_3D = np.dstack([rvs2_2D,rvs2_2D,rvs2_2D])
+ t,p = stats.ttest_ind(rvs1_3D, rvs2_3D, axis=1)
+ assert_almost_equal(np.abs(t), np.abs(tr))
+ assert_array_almost_equal(np.abs(p), pr)
+ assert_equal(t.shape, (2, 3))
+
+ t,p = stats.ttest_ind(np.rollaxis(rvs1_3D,2), np.rollaxis(rvs2_3D,2), axis=2)
+ assert_array_almost_equal(np.abs(t), np.abs(tr))
+ assert_array_almost_equal(np.abs(p), pr)
+ assert_equal(t.shape, (3, 2))
+
+ #test zero division problem
+ t,p = stats.ttest_ind([0,0,0],[1,1,1])
+ assert_equal((np.abs(t),p), (np.inf, 0))
+ assert_equal(stats.ttest_ind([0,0,0], [0,0,0]), (1.0, 0.37390096630005898))
+
+ #check that nan in input array result in nan output
+ anan = np.array([[1,np.nan],[-1,1]])
+ assert_equal(stats.ttest_ind(anan, np.zeros((2,2))),([0, np.nan], [1,np.nan]))
+
+
+
+
+def test_ttest_1samp_new():
+ n1, n2, n3 = (10,15,20)
+ rvn1 = stats.norm.rvs(loc=5,scale=10,size=(n1,n2,n3))
+ rvn2 = stats.norm.rvs(loc=5,scale=10,size=(n1,n2,n3))
+
+ #check multidimensional array and correct axis handling
+ #deterministic rvn1 and rvn2 would be better as in test_ttest_rel
+ t1,p1 = stats.ttest_1samp(rvn1[:,:,:], np.ones((n2,n3)),axis=0)
+ t2,p2 = stats.ttest_1samp(rvn1[:,:,:], 1,axis=0)
+ t3,p3 = stats.ttest_1samp(rvn1[:,0,0], 1)
+ assert_array_almost_equal(t1,t2, decimal=14)
+ assert_almost_equal(t1[0,0],t3, decimal=14)
+ assert_equal(t1.shape, (n2,n3))
+
+ t1,p1 = stats.ttest_1samp(rvn1[:,:,:], np.ones((n1,n3)),axis=1)
+ t2,p2 = stats.ttest_1samp(rvn1[:,:,:], 1,axis=1)
+ t3,p3 = stats.ttest_1samp(rvn1[0,:,0], 1)
+ assert_array_almost_equal(t1,t2, decimal=14)
+ assert_almost_equal(t1[0,0],t3, decimal=14)
+ assert_equal(t1.shape, (n1,n3))
+
+ t1,p1 = stats.ttest_1samp(rvn1[:,:,:], np.ones((n1,n2)),axis=2)
+ t2,p2 = stats.ttest_1samp(rvn1[:,:,:], 1,axis=2)
+ t3,p3 = stats.ttest_1samp(rvn1[0,0,:], 1)
+ assert_array_almost_equal(t1,t2, decimal=14)
+ assert_almost_equal(t1[0,0],t3, decimal=14)
+ assert_equal(t1.shape, (n1,n2))
+
+ #test zero division problem
+ t,p = stats.ttest_1samp([0,0,0], 1)
+ assert_equal((np.abs(t),p), (np.inf, 0))
+ assert_equal(stats.ttest_1samp([0,0,0], 0), (1.0, 0.42264973081037427))
+
+ #check that nan in input array result in nan output
+ anan = np.array([[1,np.nan],[-1,1]])
+ assert_equal(stats.ttest_1samp(anan, 0),([0, np.nan], [1,np.nan]))
+
+
+
if __name__ == "__main__":
run_module_suite()
From scipy-svn at scipy.org Sun Dec 21 17:23:35 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sun, 21 Dec 2008 16:23:35 -0600 (CST)
Subject: [Scipy-svn] r5286 - trunk/doc/source
Message-ID: <20081221222335.37013C7C062@scipy.org>
Author: josef
Date: 2008-12-21 16:23:31 -0600 (Sun, 21 Dec 2008)
New Revision: 5286
Added:
trunk/doc/source/stats.mstats.rst
Log:
add function list for stats.mstats; list was autogenerated and not yet sorted or screened for unimportant functions
Added: trunk/doc/source/stats.mstats.rst
===================================================================
--- trunk/doc/source/stats.mstats.rst 2008-12-21 17:33:40 UTC (rev 5285)
+++ trunk/doc/source/stats.mstats.rst 2008-12-21 22:23:31 UTC (rev 5286)
@@ -0,0 +1,82 @@
+.. module:: scipy.stats.mstats
+
+===================================================================
+Statistical functions for masked arrays (:mod:`scipy.stats.mstats`)
+===================================================================
+
+This module contains a large number of statistical functions that can
+be used with masked arrays.
+
+Most of these functions are similar to those in scipy.stats but might
+have small differences in the API or in the algorithm used. Since this
+is a relatively new package, some API changes are still possible.
+
+.. autosummary::
+ :toctree: generated/
+
+
+argstoarray
+betai
+chisquare
+count_tied_groups
+describe
+f_oneway
+f_value_wilks_lambda
+find_repeats
+friedmanchisquare
+gmean
+hmean
+kendalltau
+kendalltau_seasonal
+kruskalwallis
+kruskalwallis
+ks_twosamp
+ks_twosamp
+kurtosis
+kurtosistest
+linregress
+mannwhitneyu
+plotting_positions
+mode
+moment
+mquantiles
+msign
+normaltest
+obrientransform
+pearsonr
+plotting_positions
+pointbiserialr
+rankdata
+samplestd
+samplevar
+scoreatpercentile
+sem
+signaltonoise
+skew
+skewtest
+spearmanr
+std
+stderr
+theilslopes
+threshold
+tmax
+tmean
+tmin
+trim
+trima
+trimboth
+trimmed_stde
+trimr
+trimtail
+tsem
+ttest_onesamp
+ttest_ind
+ttest_onesamp
+ttest_rel
+tvar
+var
+variation
+winsorize
+z
+zmap
+zs
From scipy-svn at scipy.org Wed Dec 24 16:40:14 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 24 Dec 2008 15:40:14 -0600 (CST)
Subject: [Scipy-svn] r5287 - trunk/scipy/stats
Message-ID: <20081224214014.ECE5DC7C00B@scipy.org>
Author: josef
Date: 2008-12-24 15:40:10 -0600 (Wed, 24 Dec 2008)
New Revision: 5287
Modified:
trunk/scipy/stats/morestats.py
Log:
remove broken usage of xplt, make usage of matplotlib possible. no tests added, visual inspection
Modified: trunk/scipy/stats/morestats.py
===================================================================
--- trunk/scipy/stats/morestats.py 2008-12-21 22:23:31 UTC (rev 5286)
+++ trunk/scipy/stats/morestats.py 2008-12-24 21:40:10 UTC (rev 5287)
@@ -251,21 +251,16 @@
# perform a linear fit.
slope, intercept, r, prob, sterrest = stats.linregress(osm,osr)
if plot is not None:
- try:
- import scipy.xplt as xplt
- xplt.limits()
- except: pass
plot.plot(osm, osr, 'o', osm, slope*osm + intercept)
plot.title('Probability Plot')
plot.xlabel('Order Statistic Medians')
plot.ylabel('Ordered Values')
- try: plot.expand_limits(5)
- except: pass
+
xmin,xmax= amin(osm),amax(osm)
ymin,ymax= amin(x),amax(x)
- pos = xmin+0.70*(xmax-xmin), ymin+0.01*(ymax-ymin)
- try: plot.addtext("r^2^=%1.4f" % r, xy=pos,tosys=1)
- except: pass
+ posx,posy = xmin+0.70*(xmax-xmin), ymin+0.01*(ymax-ymin)
+ #plot.addtext("r^2^=%1.4f" % r, xy=pos,tosys=1)
+ plot.text(posx,posy, "r^2=%1.4f" % r)
if fit:
return (osm, osr), (slope, intercept, r)
else:
@@ -326,16 +321,10 @@
ppcc[k] = r2[-1]
k += 1
if plot is not None:
- try:
- import scipy.xplt as xplt
- xplt.limits()
- except: pass
plot.plot(svals, ppcc, 'x')
plot.title('(%s) PPCC Plot' % dist)
- plot.xlabel('Prob Plot Corr. Coef.',deltay=-0.01)
- plot.ylabel('Shape Values',deltax=-0.01)
- try: plot.expand_limits(5)
- except: pass
+ plot.xlabel('Prob Plot Corr. Coef.')#,deltay=-0.01)
+ plot.ylabel('Shape Values')#,deltax=-0.01)
return svals, ppcc
def boxcox_llf(lmb, data):
@@ -395,7 +384,7 @@
def tempfunc(lmb, data): # function to minimize
return -boxcox_llf(lmb,data)
lmax = optimize.brent(tempfunc, brack=(-2.0,2.0),args=(x,))
- y, lmax = boxcox(x, lmax)
+ y = boxcox(x, lmax)
if alpha is None:
return y, lmax
# Otherwise find confidence interval
@@ -429,20 +418,16 @@
ppcc = svals*0.0
k = 0
for sval in svals:
- r1,r2 = probplot(x,dist='norm',fit=1)
+ #JP: this doesn't use sval, creates constant ppcc, and horizontal line
+ z = boxcox(x,sval) #JP: this was missing
+ r1,r2 = probplot(z,dist='norm',fit=1)
ppcc[k] = r2[-1]
k +=1
if plot is not None:
- try:
- import scipy.xplt as xplt
- xplt.limits()
- except: pass
plot.plot(svals, ppcc, 'x')
plot.title('Box-Cox Normality Plot')
- plot.xlabel('Prob Plot Corr. Coef.',deltay=-0.01)
- plot.ylabel('Transformation parameter',deltax=-0.01)
- try: plot.expand_limits(5)
- except: pass
+ plot.xlabel('Prob Plot Corr. Coef.')
+ plot.ylabel('Transformation parameter')
return svals, ppcc
def shapiro(x,a=None,reta=0):
@@ -957,7 +942,9 @@
def wilcoxon(x,y=None):
"""
-Calculates the Wilcoxon signed-rank test for the null hypothesis that two samples come from the same distribution. A non-parametric T-test. (need N > 20)
+Calculates the Wilcoxon signed-rank test for the null hypothesis that two
+samples come from the same distribution. A non-parametric T-test.
+(need N > 20)
Returns: t-statistic, two-tailed p-value
"""
From scipy-svn at scipy.org Wed Dec 24 16:44:55 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 24 Dec 2008 15:44:55 -0600 (CST)
Subject: [Scipy-svn] r5288 - trunk/scipy/stats
Message-ID: <20081224214455.5F9B7C7C00B@scipy.org>
Author: josef
Date: 2008-12-24 15:44:53 -0600 (Wed, 24 Dec 2008)
New Revision: 5288
Modified:
trunk/scipy/stats/stats.py
Log:
kurtosistest: return number instead of 0-dim array
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-24 21:40:10 UTC (rev 5287)
+++ trunk/scipy/stats/stats.py 2008-12-24 21:44:53 UTC (rev 5288)
@@ -925,6 +925,9 @@
term2 = np.where(denom < 0, term1, np.power((1-2.0/A)/denom,1/3.0))
Z = ( term1 - term2 ) / np.sqrt(2/(9.0*A))
Z = np.where(denom == 99, 0, Z)
+ if Z.ndim == 0:
+ Z = Z[()]
+ #JPNote: p-value sometimes larger than 1
return Z, (1.0-zprob(Z))*2
From scipy-svn at scipy.org Fri Dec 26 17:03:46 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Fri, 26 Dec 2008 16:03:46 -0600 (CST)
Subject: [Scipy-svn] r5289 - trunk/scipy/stats
Message-ID: <20081226220346.D4C5BC7C027@scipy.org>
Author: josef
Date: 2008-12-26 16:03:43 -0600 (Fri, 26 Dec 2008)
New Revision: 5289
Modified:
trunk/scipy/stats/stats.py
Log:
cleanup docstrings of t-tests and ks-tests
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-24 21:44:53 UTC (rev 5288)
+++ trunk/scipy/stats/stats.py 2008-12-26 22:03:43 UTC (rev 5289)
@@ -1874,11 +1874,29 @@
#####################################
def ttest_1samp(a, popmean, axis=0):
- """
-Calculates the t-obtained for the independent samples T-test on ONE group
-of scores a, given a population mean.
+ """Calculates the T-test for the mean of ONE group of scores `a`.
-Returns: t-value, two-tailed prob
+ This is a two-sided test for the null hypothesis that the expected value
+ (mean) of a sample of independent observations is equal to the given
+ population mean, `popmean`.
+
+ Parameters
+ ----------
+ a : array_like
+ sample observation
+ popmean : float or array_like
+ expected value in null hypothesis, if array_like than it must have the
+ same shape as `a` excluding the axis dimension
+ axis : int, optional, (default axis=0)
+ Axis can equal None (ravel array first), or an integer (the axis
+ over which to operate on a).
+
+ Returns
+ -------
+ t : float or array
+ t-statistic
+ prob : float or array
+ two-tailed p-value
"""
@@ -1904,31 +1922,46 @@
def ttest_ind(a, b, axis=0):
- """Calculates the t-obtained T-test on TWO INDEPENDENT samples of scores
- a, and b. From Numerical Recipies, p.483. Axis can equal None (ravel
- array first), or an integer (the axis over which to operate on a and b).
+ """Calculates the T-test for the means of TWO INDEPENDENT samples of scores.
- Returns: t-value, two-tailed p-value
-
This is a two-sided test for the null hypothesis that 2 independent samples
have identical average (expected) values.
- Description
- -----------
+ Parameters
+ ----------
+ a, b : sequence of ndarrays
+ The arrays must have the same shape, except in the dimension
+ corresponding to `axis` (the first, by default).
+ axis : int, optional
+ Axis can equal None (ravel array first), or an integer (the axis
+ over which to operate on a and b).
+ Returns
+ -------
+ t : float or array
+ t-statistic
+ prob : float or array
+ two-tailed p-value
+
+
+ Notes
+ -----
+
We can use this test, if we observe two independent samples from
the same or different population, e.g. exam scores of boys and
girls or of two ethnic groups. The test measures whether the
average (expected) value differs significantly across samples. If
- we observe a larger p-value, for example >0.5 or 0.1 then we
- cannot reject the null hypothesis of identical average scores. If
- the test statistic is larger (in absolute terms than critical
- value or, equivalently, if the p-value is smaller than the
- threshold, 1%,5% or 10%, then we reject the null hypothesis equal
- averages.
+ we observe a large p-value, for example larger than 0.05 or 0.1,
+ then we cannot reject the null hypothesis of identical average scores.
+ If the p-value is smaller than the threshold, e.g. 1%, 5% or 10%,
+ then we reject the null hypothesis of equal averages.
- see: http://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test
+ References
+ ----------
+ http://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test
+
+
Examples
--------
@@ -1941,13 +1974,13 @@
# test with sample with identical means
>>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500)
- >>> ttest_ind(rvs1,rvs2)
+ >>> stats.ttest_ind(rvs1,rvs2)
(0.26833823296239279, 0.78849443369564765)
# test with sample with different means
>>> rvs3 = stats.norm.rvs(loc=8,scale=10,size=500)
- >>> ttest_ind(rvs1,rvs3)
+ >>> stats.ttest_ind(rvs1,rvs3)
(-5.0434013458585092, 5.4302979468623391e-007)
"""
@@ -1979,30 +2012,45 @@
def ttest_rel(a,b,axis=0):
- """Calculates the t-obtained T-test on TWO RELATED samples of scores, a
- and b. From Numerical Recipies, p.483. Axis can equal None (ravel array
- first), or an integer (the axis over which to operate on a and b).
+ """Calculates the T-test on TWO RELATED samples of scores, a and b.
- Returns: t-value, two-tailed p-value
+ This is a two-sided test for the null hypothesis that 2 related or
+ repeated samples have identical average (expected) values.
- Description
- -----------
+ Parameters
+ ----------
+ a, b : sequence of ndarrays
+ The arrays must have the same shape.
+ axis : int, optional, (default axis=0)
+ Axis can equal None (ravel array first), or an integer (the axis
+ over which to operate on a and b).
- This is a two-sided test for the null hypothesis that 2 repeated samples
- have identical average values.
+ Returns
+ -------
+ t : float or array
+ t-statistic
+ prob : float or array
+ two-tailed p-value
- Examples for the use are scores of a student in different exams,
- or repeated sampling from the same units. The test measures
- whether the average score differs significantly across samples
- (e.g. exams). If we observe a larger p-value, for example >0.5 or
- 0.1 then we cannot reject the null hypothesis of identical average
- scores. If the test statistic is larger (in absolute terms than
- critical value or, equivalently, if the p-value is smaller than
- the threshold, 1%,5% or 10%, then we reject the null hypothesis
- equal averages.
- see: http://en.wikipedia.org/wiki/T-test#Dependent_t-test
+ Notes
+ -----
+ Examples for the use are scores of the same set of student in
+ different exams, or repeated sampling from the same units. The
+ test measures whether the average score differs significantly
+ across samples (e.g. exams). If we observe a large p-value, for
+ example greater than 0.5 or 0.1 then we cannot reject the null
+ hypothesis of identical average scores. If the p-value is smaller
+ than the threshold, e.g. 1%, 5% or 10%, then we reject the null
+ hypothesis of equal averages. Small p-values are associated with
+ large t-statistics.
+
+ References
+ ----------
+
+ http://en.wikipedia.org/wiki/T-test#Dependent_t-test
+
Examples
--------
@@ -2056,24 +2104,17 @@
def kstest(rvs, cdf, args=(), N=20, alternative = 'two_sided', mode='approx',**kwds):
"""Return the D-value and the p-value for a Kolmogorov-Smirnov test
+ This performs a test of the distribution G(x) of an observed
+ random variable against a given distribution F(x). Under the null
+ hypothesis the two distributions are identical, G(x)=F(x). The
+ alternative hypothesis can be either 'two_sided' (default), 'less'
+ or 'greater'. The KS test is only valid for continuous distributions.
- This performs a test of the distribution of random variables G(x) against
- a given distribution F(x). Under the null hypothesis the two distributions
- are identical, G(x)=F(x). The alternative hypothesis can be either
- 'two_sided' (default), 'less' or 'greater'. In the two one-sided test,
- the alternative is that the empirical cumulative distribution function,
- of the random variable is "less" or "greater" then the cumulative
- distribution function of the hypothesis F(x), G(x)<=F(x), resp. G(x)>=F(x).
-
- If the p-value is greater than the significance level (say 5%), then we
- cannot reject the hypothesis that the data come from the given
- distribution.
-
Parameters
----------
rvs : string or array or callable
string: name of a distribution in scipy.stats
- array: random variables
+ array: 1-D observations of random variables
callable: function to generate random variables,
requires keyword argument size
cdf : string or callable
@@ -2082,21 +2123,37 @@
or be the same as rvs
callable: function to evaluate cdf
- args : distribution parameters used if rvs or cdf are strings
- N : sample size if rvs is string or callable
+ args : tuple, sequence
+ distribution parameters, used if rvs or cdf are strings
+ N : int
+ sample size if rvs is string or callable
alternative : 'two_sided' (default), 'less' or 'greater'
defines the alternative hypothesis (see explanation)
mode : 'approx' (default) or 'asymp'
- defines distribution used for calculating p-value
+ defines the distribution used for calculating p-value
'approx' : use approximation to exact distribution of test statistic
'asymp' : use asymptotic distribution of test statistic
Returns
-------
- D: test statistic either D, D+ or D-
- p-value
+ D : float
+ KS test statistic, either D, D+ or D-
+ p-value : float
+ one-tailed or two-tailed p-value
+ Notes
+ -----
+
+ In the two one-sided test, the alternative is that the empirical
+ cumulative distribution function of the random variable is "less"
+ or "greater" then the cumulative distribution function F(x) of the
+ hypothesis, G(x)<=F(x), resp. G(x)>=F(x).
+
+ If the p-value is greater than the significance level (say 5%), then we
+ cannot reject the hypothesis that the data come from the given
+ distribution.
+
Examples
--------
@@ -2214,25 +2271,37 @@
def ks_2samp(data1, data2):
""" Computes the Kolmogorov-Smirnof statistic on 2 samples.
- data1, data2: array_like, 1-dim
- samples assumed to be drawn from a continuous distribution,
- sample sizes can be different
+ This is a two-sided test for the null hypothesis that 2 independent samples
+ are drawn from the same continuous distribution.
- Returns: KS D-value, p-value
+ Parameters
+ ----------
+ a, b : sequence of 1-D ndarrays
+ two arrays of sample observations assumed to be drawn from a continuous
+ distribution, sample sizes can be different
- Description:
- ------------
- Tests whether 2 samples are drawn from the same distribution. Note
- that, like the one-sample K-S test the distribution is assumed to be
- continuous.
+ Returns
+ -------
+ D : float
+ KS statistic
+ p-value : float
+ two-tailed p-value
+
+ Notes
+ -----
+
+ This tests whether 2 samples are drawn from the same distribution. Note
+ that, like in the case of the one-sample K-S test, the distribution is
+ assumed to be continuous.
+
This is the two-sided test, one-sided tests are not implemented.
The test uses the two-sided asymptotic Kolmogorov-Smirnov distribution.
If the K-S statistic is small or the p-value is high, then we cannot
- reject the hypothesis that the two distributions of the two samples
- are the same
+ reject the hypothesis that the distributions of the two samples
+ are the same.
Examples:
---------
From scipy-svn at scipy.org Fri Dec 26 19:46:26 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Fri, 26 Dec 2008 18:46:26 -0600 (CST)
Subject: [Scipy-svn] r5290 - trunk/scipy/stats
Message-ID: <20081227004626.C4464C7C027@scipy.org>
Author: josef
Date: 2008-12-26 18:46:24 -0600 (Fri, 26 Dec 2008)
New Revision: 5290
Modified:
trunk/scipy/stats/stats.py
Log:
docstring cleaning and add example to ttest_1samp
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-26 22:03:43 UTC (rev 5289)
+++ trunk/scipy/stats/stats.py 2008-12-27 00:46:24 UTC (rev 5290)
@@ -1897,6 +1897,37 @@
t-statistic
prob : float or array
two-tailed p-value
+
+ Examples
+ --------
+
+ >>> from scipy import stats
+ >>> import numpy as np
+
+ >>> #fix seed to get the same result
+ >>> np.random.seed(7654567)
+ >>> rvs = stats.norm.rvs(loc=5,scale=10,size=(50,2))
+
+ test if mean of random sample is equal to true mean, and different mean.
+ We reject the null hypothesis in the second case and don't reject it in
+ the first case
+
+ >>> stats.ttest_1samp(rvs,5.0)
+ (array([-0.68014479, -0.04323899]), array([ 0.49961383, 0.96568674]))
+ >>> stats.ttest_1samp(rvs,0.0)
+ (array([ 2.77025808, 4.11038784]), array([ 0.00789095, 0.00014999]))
+
+ examples using axis and non-scalar dimension for population mean
+
+ >>> stats.ttest_1samp(rvs,[5.0,0.0])
+ (array([-0.68014479, 4.11038784]), array([ 4.99613833e-01, 1.49986458e-04]))
+ >>> stats.ttest_1samp(rvs.T,[5.0,0.0],axis=1)
+ (array([-0.68014479, 4.11038784]), array([ 4.99613833e-01, 1.49986458e-04]))
+ >>> stats.ttest_1samp(rvs,[[5.0],[0.0]])
+ (array([[-0.68014479, -0.04323899],
+ [ 2.77025808, 4.11038784]]), array([[ 4.99613833e-01, 9.65686743e-01],
+ [ 7.89094663e-03, 1.49986458e-04]]))
+
"""
@@ -1968,17 +1999,19 @@
>>> from scipy import stats
>>> import numpy as np
- #fix seed to get the same result
+ >>> #fix seed to get the same result
>>> np.random.seed(12345678)
- # test with sample with identical means
+ test with sample with identical means
+
>>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> stats.ttest_ind(rvs1,rvs2)
(0.26833823296239279, 0.78849443369564765)
- # test with sample with different means
+ test with sample with different means
+
>>> rvs3 = stats.norm.rvs(loc=8,scale=10,size=500)
>>> stats.ttest_ind(rvs1,rvs3)
(-5.0434013458585092, 5.4302979468623391e-007)
@@ -2057,7 +2090,7 @@
>>> from scipy import stats
>>> import numpy as np
- #fix random seed to get the same result
+ >>> #fix random seed to get the same result
>>> np.random.seed(12345678)
>>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500) + \
@@ -2114,13 +2147,17 @@
----------
rvs : string or array or callable
string: name of a distribution in scipy.stats
+
array: 1-D observations of random variables
+
callable: function to generate random variables,
- requires keyword argument size
+ requires keyword argument `size`
+
cdf : string or callable
string: name of a distribution in scipy.stats
- if rvs is a string then cdf can evaluate to False
- or be the same as rvs
+ if rvs is a string then cdf can evaluate to False
+ or be the same as rvs
+
callable: function to evaluate cdf
args : tuple, sequence
@@ -2131,7 +2168,9 @@
defines the alternative hypothesis (see explanation)
mode : 'approx' (default) or 'asymp'
defines the distribution used for calculating p-value
+
'approx' : use approximation to exact distribution of test statistic
+
'asymp' : use asymptotic distribution of test statistic
@@ -2165,33 +2204,33 @@
>>> kstest(x,'norm')
(0.44435602715924361, 0.038850142705171065)
- # fix random seed to get the same result
+ >>> #fix random seed to get the same result
>>> np.random.seed(987654321)
>>> kstest('norm','',N=100)
(0.058352892479417884, 0.88531190944151261)
is equivalent to this
+
>>> np.random.seed(987654321)
>>> kstest(stats.norm.rvs(size=100),'norm')
(0.058352892479417884, 0.88531190944151261)
- test against one-sided alternative hypothesis
- ---------------------------------------------
+ **test against one-sided alternative hypothesis**
+
>>> np.random.seed(987654321)
- >>> # shift distribution to larger values, so that cdf_dgp(x)< norm.cdf(x)
+ >>> #shift distribution to larger values, so that cdf_dgp(x)< norm.cdf(x)
>>> x = stats.norm.rvs(loc=0.2, size=100)
>>> kstest(x,'norm', alternative = 'less')
(0.12464329735846891, 0.040989164077641749)
- >>> # reject equal distribution against alternative hypothesis: less
+ >>> #reject equal distribution against alternative hypothesis: less
>>> kstest(x,'norm', alternative = 'greater')
(0.0072115233216311081, 0.98531158590396395)
- >>> # don't reject equal distribution against alternative hypothesis: greater
+ >>> #don't reject equal distribution against alternative hypothesis: greater
>>> kstest(x,'norm', mode='asymp')
(0.12464329735846891, 0.08944488871182088)
- testing t distributed random variables against normal distribution
- ------------------------------------------------------------------
+ **testing t distributed random variables against normal distribution**
With 100 degrees of freedom the t distribution looks close to the normal
distribution, and the kstest does not reject the hypothesis that the sample
@@ -2201,7 +2240,6 @@
>>> stats.kstest(stats.t.rvs(100,size=100),'norm')
(0.072018929165471257, 0.67630062862479168)
-
With 3 degrees of freedom the t distribution looks sufficiently different
from the normal distribution, that we can reject the hypothesis that the
sample came from the normal distribution at a alpha=10% level
@@ -2310,14 +2348,15 @@
>>> import numpy as np
>>> from scipy.stats import ks_2samp
- # fix random seed to get the same result
+ >>> #fix random seed to get the same result
>>> np.random.seed(12345678);
>>> n1 = 200 # size of first sample
>>> n2 = 300 # size of second sample
- # different distribution
+ different distribution
we can reject the null hypothesis since the pvalue is below 1%
+
>>> rvs1 = stats.norm.rvs(size=n1,loc=0.,scale=1);
>>> rvs2 = stats.norm.rvs(size=n2,loc=0.5,scale=1.5)
>>> ks_2samp(rvs1,rvs2)
@@ -2326,12 +2365,14 @@
slightly different distribution
we cannot reject the null hypothesis at a 10% or lower alpha since
the pvalue at 0.144 is higher than 10%
+
>>> rvs3 = stats.norm.rvs(size=n2,loc=0.01,scale=1.0)
>>> ks_2samp(rvs1,rvs3)
(0.10333333333333333, 0.14498781825751686)
identical distribution
we cannot reject the null hypothesis since the pvalue is high, 41%
+
>>> rvs4 = stats.norm.rvs(size=n2,loc=0.0,scale=1.0)
>>> ks_2samp(rvs1,rvs4)
(0.07999999999999996, 0.41126949729859719)
From scipy-svn at scipy.org Sat Dec 27 06:31:15 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 27 Dec 2008 05:31:15 -0600 (CST)
Subject: [Scipy-svn] r5291 - trunk
Message-ID: <20081227113115.106F2C7C02B@scipy.org>
Author: jarrod.millman
Date: 2008-12-27 05:31:13 -0600 (Sat, 27 Dec 2008)
New Revision: 5291
Modified:
trunk/THANKS.txt
Log:
added Per
Modified: trunk/THANKS.txt
===================================================================
--- trunk/THANKS.txt 2008-12-27 00:46:24 UTC (rev 5290)
+++ trunk/THANKS.txt 2008-12-27 11:31:13 UTC (rev 5291)
@@ -50,6 +50,7 @@
Tiziano Zito for generalized symmetric and hermitian eigenvalue problem
solver.
Chris Burns for bug-fixes.
+Per Brodtkorb for improvements to stats distributions
Institutions
------------
From scipy-svn at scipy.org Sat Dec 27 16:44:25 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 27 Dec 2008 15:44:25 -0600 (CST)
Subject: [Scipy-svn] r5292 - in trunk/scipy/sparse: . tests
Message-ID: <20081227214425.CB19BC7C009@scipy.org>
Author: wnbell
Date: 2008-12-27 15:44:20 -0600 (Sat, 27 Dec 2008)
New Revision: 5292
Modified:
trunk/scipy/sparse/construct.py
trunk/scipy/sparse/tests/test_construct.py
Log:
fixed sparse.eye() with k != 0
resolves ticket #825
Modified: trunk/scipy/sparse/construct.py
===================================================================
--- trunk/scipy/sparse/construct.py 2008-12-27 11:31:13 UTC (rev 5291)
+++ trunk/scipy/sparse/construct.py 2008-12-27 21:44:20 UTC (rev 5292)
@@ -99,14 +99,16 @@
else:
return identity(n, dtype=dtype, format='csr').asformat(format)
+
def eye(m, n, k=0, dtype='d', format=None):
"""eye(m, n) returns a sparse (m x n) matrix where the k-th diagonal
is all ones and everything else is zeros.
"""
m,n = int(m),int(n)
- diags = np.ones((1, min(m,n)), dtype=dtype)
+ diags = np.ones((1, min(m + k, n)), dtype=dtype)
return spdiags(diags, k, m, n).asformat(format)
+
def kron(A, B, format=None):
"""kronecker product of sparse matrices A and B
Modified: trunk/scipy/sparse/tests/test_construct.py
===================================================================
--- trunk/scipy/sparse/tests/test_construct.py 2008-12-27 11:31:13 UTC (rev 5291)
+++ trunk/scipy/sparse/tests/test_construct.py 2008-12-27 21:44:20 UTC (rev 5292)
@@ -1,6 +1,6 @@
"""test sparse matrix construction functions"""
-import numpy
+import numpy as np
from numpy import array, matrix
from numpy.testing import *
@@ -83,6 +83,16 @@
assert_equal(eye(3,3,dtype='int16').dtype, 'int16')
+ assert_equal(eye(3, 4, -4).toarray(), np.eye(3, 4, -4))
+ assert_equal(eye(3, 4, -3).toarray(), np.eye(3, 4, -3))
+ assert_equal(eye(3, 4, -2).toarray(), np.eye(3, 4, -2))
+ assert_equal(eye(3, 4, -1).toarray(), np.eye(3, 4, -1))
+ assert_equal(eye(3, 4, 0).toarray(), np.eye(3, 4, 0))
+ assert_equal(eye(3, 4, 1).toarray(), np.eye(3, 4, 1))
+ assert_equal(eye(3, 4, 2).toarray(), np.eye(3, 4, 2))
+ assert_equal(eye(3, 4, 3).toarray(), np.eye(3, 4, 3))
+ assert_equal(eye(3, 4, 4).toarray(), np.eye(3, 4, 4))
+
def test_kron(self):
cases = []
@@ -103,7 +113,7 @@
for a in cases:
for b in cases:
result = kron(csr_matrix(a),csr_matrix(b)).todense()
- expected = numpy.kron(a,b)
+ expected = np.kron(a,b)
assert_array_equal(result,expected)
def test_kronsum(self):
@@ -121,8 +131,8 @@
for a in cases:
for b in cases:
result = kronsum(csr_matrix(a),csr_matrix(b)).todense()
- expected = numpy.kron(numpy.eye(len(b)), a) + \
- numpy.kron(b, numpy.eye(len(a)))
+ expected = np.kron(np.eye(len(b)), a) + \
+ np.kron(b, np.eye(len(a)))
assert_array_equal(result,expected)
def test_vstack(self):
From scipy-svn at scipy.org Sat Dec 27 16:53:03 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 27 Dec 2008 15:53:03 -0600 (CST)
Subject: [Scipy-svn] r5293 - in trunk/scipy/sparse: . tests
Message-ID: <20081227215303.79C6AC7C009@scipy.org>
Author: wnbell
Date: 2008-12-27 15:52:58 -0600 (Sat, 27 Dec 2008)
New Revision: 5293
Modified:
trunk/scipy/sparse/construct.py
trunk/scipy/sparse/tests/test_construct.py
Log:
fixed other bugs in sparse.eye
Modified: trunk/scipy/sparse/construct.py
===================================================================
--- trunk/scipy/sparse/construct.py 2008-12-27 21:44:20 UTC (rev 5292)
+++ trunk/scipy/sparse/construct.py 2008-12-27 21:52:58 UTC (rev 5293)
@@ -105,7 +105,7 @@
is all ones and everything else is zeros.
"""
m,n = int(m),int(n)
- diags = np.ones((1, min(m + k, n)), dtype=dtype)
+ diags = np.ones((1, max(0, min(m + k, n))), dtype=dtype)
return spdiags(diags, k, m, n).asformat(format)
Modified: trunk/scipy/sparse/tests/test_construct.py
===================================================================
--- trunk/scipy/sparse/tests/test_construct.py 2008-12-27 21:44:20 UTC (rev 5292)
+++ trunk/scipy/sparse/tests/test_construct.py 2008-12-27 21:52:58 UTC (rev 5293)
@@ -83,15 +83,10 @@
assert_equal(eye(3,3,dtype='int16').dtype, 'int16')
- assert_equal(eye(3, 4, -4).toarray(), np.eye(3, 4, -4))
- assert_equal(eye(3, 4, -3).toarray(), np.eye(3, 4, -3))
- assert_equal(eye(3, 4, -2).toarray(), np.eye(3, 4, -2))
- assert_equal(eye(3, 4, -1).toarray(), np.eye(3, 4, -1))
- assert_equal(eye(3, 4, 0).toarray(), np.eye(3, 4, 0))
- assert_equal(eye(3, 4, 1).toarray(), np.eye(3, 4, 1))
- assert_equal(eye(3, 4, 2).toarray(), np.eye(3, 4, 2))
- assert_equal(eye(3, 4, 3).toarray(), np.eye(3, 4, 3))
- assert_equal(eye(3, 4, 4).toarray(), np.eye(3, 4, 4))
+ for m in [3, 5]:
+ for n in [3, 5]:
+ for k in range(-5,6):
+ assert_equal(eye(m, n, k=k).toarray(), np.eye(m, n, k=k))
def test_kron(self):
cases = []
From scipy-svn at scipy.org Sat Dec 27 18:34:17 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Sat, 27 Dec 2008 17:34:17 -0600 (CST)
Subject: [Scipy-svn] r5294 - in trunk/scipy/sparse: . tests
Message-ID: <20081227233417.0B005C7C009@scipy.org>
Author: wnbell
Date: 2008-12-27 17:34:08 -0600 (Sat, 27 Dec 2008)
New Revision: 5294
Modified:
trunk/scipy/sparse/base.py
trunk/scipy/sparse/tests/test_base.py
Log:
check for matrix dimensions in sparse * sparse
Modified: trunk/scipy/sparse/base.py
===================================================================
--- trunk/scipy/sparse/base.py 2008-12-27 21:52:58 UTC (rev 5293)
+++ trunk/scipy/sparse/base.py 2008-12-27 23:34:08 UTC (rev 5294)
@@ -283,6 +283,8 @@
return self._mul_scalar(other)
if issparse(other):
+ if self.shape[1] != other.shape[0]:
+ raise ValueError('dimension mismatch')
return self._mul_sparse_matrix(other)
try:
Modified: trunk/scipy/sparse/tests/test_base.py
===================================================================
--- trunk/scipy/sparse/tests/test_base.py 2008-12-27 21:52:58 UTC (rev 5293)
+++ trunk/scipy/sparse/tests/test_base.py 2008-12-27 23:34:08 UTC (rev 5294)
@@ -446,6 +446,12 @@
assert_array_almost_equal(B.todense(), A.todense() * A.T.todense())
assert_array_almost_equal(B.todense(), A.todense() * A.todense().T)
+
+ # check dimension mismatch 2x2 times 3x2
+ A = self.spmatrix( [[1,2],[3,4]] )
+ B = self.spmatrix( [[1,2],[3,4],[5,6]] )
+ assert_raises(ValueError, A.__mul__, B)
+
def test_matmat_dense(self):
a = matrix([[3,0,0],[0,1,0],[2,0,3.0],[2,3,0]])
asp = self.spmatrix(a)
From scipy-svn at scipy.org Mon Dec 29 01:04:24 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Mon, 29 Dec 2008 00:04:24 -0600 (CST)
Subject: [Scipy-svn] r5295 - trunk/doc/release
Message-ID: <20081229060424.280E7C7C007@scipy.org>
Author: cdavid
Date: 2008-12-29 00:04:19 -0600 (Mon, 29 Dec 2008)
New Revision: 5295
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
Add python 2.6 notes in the scipy 0.7.0 release notes.
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-27 23:34:08 UTC (rev 5294)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-29 06:04:19 UTC (rev 5295)
@@ -238,3 +238,20 @@
Support for NumScons has been added. NumScons is a tentative new
build system for NumPy/SciPy, using scons at its core.
+
+Python 2.6 and 3.0
+------------------
+
+Python 3.0 is not supported at all: it requires numpy to be ported to python
+3.0, which is a massive effort, since a lot of C code has to be ported. It will
+happen, but not anytime soon.
+
+The main issue with 2.6 support is numpy. On Unix (including Mac OS X), numpy
+1.2.1 mostly works, with a few caveats. On windows, there are some problems
+related to the compilation process. The upcoming 1.3 version of numpy will fix
+those. Then, because of some python 2.6 bugs, f2py does not work on python 2.6;
+the fixes will also be in the upcoming numpy 1.3.
+
+The bottom line: if you can avoid it, do not use python 2.6 yet for
+numpy/scipy. If you really need scipy on python 2.6, then it is recommended
+have to build numpy from svn by yourself, and then build scipy.
From scipy-svn at scipy.org Tue Dec 30 08:49:23 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 07:49:23 -0600 (CST)
Subject: [Scipy-svn] r5296 - trunk/scipy/special
Message-ID: <20081230134923.F2F3FC7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-30 07:49:22 -0600 (Tue, 30 Dec 2008)
New Revision: 5296
Modified:
trunk/scipy/special/orthogonal.py
Log:
clarified relationship to NR code as explained on the maling list by Chuck Harris, Alan Isaac, and Fernando Perez
Modified: trunk/scipy/special/orthogonal.py
===================================================================
--- trunk/scipy/special/orthogonal.py 2008-12-29 06:04:19 UTC (rev 5295)
+++ trunk/scipy/special/orthogonal.py 2008-12-30 13:49:22 UTC (rev 5296)
@@ -34,8 +34,9 @@
P_0(x) = 1
P_-1(x) == 0
-See Numerical Recipies in C, page 156 and
-Abramowitz and Stegun p. 774, 782
+For a more detailed discussion see Numerical Recipies in C (p. 156) and
+Abramowitz and Stegun (p. 774, 782); while our implementation differs, the
+algorithm and formulas are similar.
Functions:
From scipy-svn at scipy.org Tue Dec 30 08:52:32 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 07:52:32 -0600 (CST)
Subject: [Scipy-svn] r5297 - trunk/scipy/optimize
Message-ID: <20081230135232.ECF07C7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-30 07:52:27 -0600 (Tue, 30 Dec 2008)
New Revision: 5297
Modified:
trunk/scipy/optimize/zeros.py
Log:
clean up text
Modified: trunk/scipy/optimize/zeros.py
===================================================================
--- trunk/scipy/optimize/zeros.py 2008-12-30 13:49:22 UTC (rev 5296)
+++ trunk/scipy/optimize/zeros.py 2008-12-30 13:52:27 UTC (rev 5297)
@@ -141,9 +141,9 @@
-----
Uses [Ridders1979]_ method to find a zero of the function `f` between the
arguments `a` and `b`. Ridders' method is faster than bisection, but not
- generaly as fast as the brent rountines. [Ridders1979]_ provides the
+ generally as fast as the Brent rountines. [Ridders1979]_ provides the
classic description and source of the algorithm. A description can also be
- found in may be found in any recent edition of Numerical Recipes.
+ found in any recent edition of Numerical Recipes.
The routine used here diverges slightly from standard presentations in
order to be a bit more careful of tolerance.
@@ -180,7 +180,7 @@
claims convergence is guaranteed for functions computable within [a,b].
[Brent1973]_ provides the classic description of the algorithm. Another
- description is in any recent edition of Numerical Recipes, including
+ description can be found in a recent edition of Numerical Recipes, including
[PressEtal1992]_. Another description is at
http://mathworld.wolfram.com/BrentsMethod.html. It should be easy to
understand the algorithm just by reading our code. Our code diverges a bit
From scipy-svn at scipy.org Tue Dec 30 09:52:33 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 08:52:33 -0600 (CST)
Subject: [Scipy-svn] r5298 - trunk/doc/release
Message-ID: <20081230145233.8E72FC7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-30 08:52:31 -0600 (Tue, 30 Dec 2008)
New Revision: 5298
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
working on release notes
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-30 13:52:27 UTC (rev 5297)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-30 14:52:31 UTC (rev 5298)
@@ -2,10 +2,36 @@
SciPy 0.7.0 Release Notes
=========================
-This is a new stable release. Please note that unlike previous versions
-of SciPy, this release requires Python 2.4 or greater. This release also
-requires NumPy 1.2.0 or greater.
+.. contents::
+This stable release comes almost one year after the 0.6.0 release
+and contains many new features, numerous bug-fixes, improved test
+coverage, and better documentation.
+
+Please note that unlike previous versions of SciPy, this release
+requires Python 2.4 or 2.5. This release also requires NumPy 1.2.0
+or greater.
+
+.. note:: Python 2.6 and 3.0
+
+ Python 3.0 is not supported at all: it requires NumPy to be ported to
+ Python 3.0, which is a massive effort, since a lot of C code has to be
+ ported. It will happen, but not anytime soon.
+
+The main issue with 2.6 support is numpy. On Unix (including Mac OS X), numpy
+1.2.1 mostly works, with a few caveats. On windows, there are some problems
+related to the compilation process. The upcoming 1.3 version of numpy will fix
+those. Then, because of some python 2.6 bugs, f2py does not work on python 2.6;
+the fixes will also be in the upcoming numpy 1.3.
+
+The bottom line: if you can avoid it, do not use python 2.6 yet for
+numpy/scipy. If you really need scipy on python 2.6, then it is recommended
+have to build numpy from svn by yourself, and then build scipy.
+
+License review
+~~~~~~~~~~~~~~
+
+
Changes
-------
@@ -192,8 +218,8 @@
Users of ``scipy.interpolate.interp1d`` may need to revise their code
if it relies on the incorrect behavior.
-Bug fixes in the stats package
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Statistics package
+~~~~~~~~~~~~~~~~~~
Statistical functions for masked arrays have been added and are accessible
through scipy.stats.mstats. The functions are similar to their counterparts
@@ -239,19 +265,13 @@
Support for NumScons has been added. NumScons is a tentative new
build system for NumPy/SciPy, using scons at its core.
-Python 2.6 and 3.0
-------------------
+Sandbox Removed
+~~~~~~~~~~~~~~~
-Python 3.0 is not supported at all: it requires numpy to be ported to python
-3.0, which is a massive effort, since a lot of C code has to be ported. It will
-happen, but not anytime soon.
-
-The main issue with 2.6 support is numpy. On Unix (including Mac OS X), numpy
-1.2.1 mostly works, with a few caveats. On windows, there are some problems
-related to the compilation process. The upcoming 1.3 version of numpy will fix
-those. Then, because of some python 2.6 bugs, f2py does not work on python 2.6;
-the fixes will also be in the upcoming numpy 1.3.
-
-The bottom line: if you can avoid it, do not use python 2.6 yet for
-numpy/scipy. If you really need scipy on python 2.6, then it is recommended
-have to build numpy from svn by yourself, and then build scipy.
+While porting SciPy to NumPy in 2005, several packages and modules were moved into
+``scipy.sandbox``. The sandbox was a staging ground for packages that were undergoing
+rapid development and whose APIs were in flux. It was also a place where broken code
+could live. The sandbox has served its purpose well and was starting to create confusion,
+so ``scipy.sandbox`` was removed. Most of the code was moved into ``scipy``, some code was
+made into a ``scikit``, and the remaining code was just deleted as the functionality had
+been replaced by other code.
From scipy-svn at scipy.org Tue Dec 30 10:01:20 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 09:01:20 -0600 (CST)
Subject: [Scipy-svn] r5299 - trunk/doc/release
Message-ID: <20081230150120.8A258C7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-30 09:01:17 -0600 (Tue, 30 Dec 2008)
New Revision: 5299
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
formatting fixes
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-30 14:52:31 UTC (rev 5298)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-30 15:01:17 UTC (rev 5299)
@@ -12,26 +12,19 @@
requires Python 2.4 or 2.5. This release also requires NumPy 1.2.0
or greater.
-.. note:: Python 2.6 and 3.0
+Python 2.6 and 3.0
+~~~~~~~~~~~~~~~~~~
- Python 3.0 is not supported at all: it requires NumPy to be ported to
- Python 3.0, which is a massive effort, since a lot of C code has to be
- ported. It will happen, but not anytime soon.
+Python 3.0 is not supported at all: it requires NumPy to be ported to
+Python 3.0, which is a massive effort, since a lot of C code has to be
+ported. It will happen, but not anytime soon.
-The main issue with 2.6 support is numpy. On Unix (including Mac OS X), numpy
-1.2.1 mostly works, with a few caveats. On windows, there are some problems
-related to the compilation process. The upcoming 1.3 version of numpy will fix
-those. Then, because of some python 2.6 bugs, f2py does not work on python 2.6;
-the fixes will also be in the upcoming numpy 1.3.
+The main issue with 2.6 support is NumPy. On UNIX (including Mac OS X), NumPy
+1.2.1 mostly works, with a few caveats. On Windows, there are some problems
+related to the compilation process. The upcoming 1.3 version of NumPy will fix
+those. Then, because of some Python 2.6 bugs, ``f2py`` does not work on Python
+2.6; the fixes will also be in the upcoming NumPy 1.3.
-The bottom line: if you can avoid it, do not use python 2.6 yet for
-numpy/scipy. If you really need scipy on python 2.6, then it is recommended
-have to build numpy from svn by yourself, and then build scipy.
-
-License review
-~~~~~~~~~~~~~~
-
-
Changes
-------
From scipy-svn at scipy.org Tue Dec 30 10:04:00 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 09:04:00 -0600 (CST)
Subject: [Scipy-svn] r5300 - trunk/doc/release
Message-ID: <20081230150400.57174C7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-30 09:03:59 -0600 (Tue, 30 Dec 2008)
New Revision: 5300
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
more formatting
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-30 15:01:17 UTC (rev 5299)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-30 15:03:59 UTC (rev 5300)
@@ -13,7 +13,7 @@
or greater.
Python 2.6 and 3.0
-~~~~~~~~~~~~~~~~~~
+------------------
Python 3.0 is not supported at all: it requires NumPy to be ported to
Python 3.0, which is a massive effort, since a lot of C code has to be
@@ -25,11 +25,8 @@
those. Then, because of some Python 2.6 bugs, ``f2py`` does not work on Python
2.6; the fixes will also be in the upcoming NumPy 1.3.
-Changes
--------
-
Sparse Matrices
-~~~~~~~~~~~~~~~
+---------------
* added support for integer dtypes such ``int8``, ``uint32``, etc.
* new class ``dia_matrix`` : the sparse DIAgonal format
@@ -69,7 +66,7 @@
* numerous bugfixes
Reworking of IO package
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
The IO code in both NumPy and SciPy is undergoing a major reworking. NumPy
will be where basic code for reading and writing NumPy arrays is located,
@@ -89,7 +86,7 @@
* string arrays have ``dtype='U...'`` instead of ``dtype=object``
New Hierarchical Clustering module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------------
This module adds new hierarchical clustering functionality to the
``scipy.cluster`` package. The function interfaces are similar to the
@@ -113,7 +110,7 @@
matplotlib.
New Spatial package
-~~~~~~~~~~~~~~~~~~~
+-------------------
Collection of spatial algorithms and data structures useful for spatial
statistics and clustering applications. Includes fast compiled code for
@@ -139,14 +136,14 @@
distance matrices between square and condensed forms.
Reworked fftpack package
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
FFTW2, FFTW3, MKL and DJBFFT wrappers have been removed. Only (NETLIB)
fftpack remains. By focusing on one backend, we hope to add new
features -- like float32 support -- more easily.
New Constants package
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
``scipy.constants`` provides a collection of physical constants and
conversion factors. These constants are taken from CODATA Recommended
@@ -160,7 +157,7 @@
for everyday use.
New Radial Basis Function module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
``scipy.interpolate`` now contains a Radial Basis Function module.
Radial basis functions can be used for smoothing/interpolating scattered
@@ -168,14 +165,14 @@
outside of the observed data range.
New complex ODE integrator
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
``scipy.integrate.ode`` now contains a wrapper for the ZVODE
complex-valued ordinary differential equation solver
(by Peter N. Brown, Alan C. Hindmarsh, and George D. Byrne).
New generalized symmetric and hermitian eigenvalue problem solver
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------------------------------------------
``scipy.linalg.eigh`` now contains wrappers for more LAPACK
symmetric and hermitian eigenvalue problem solvers. Users
@@ -185,7 +182,7 @@
changed accordingly.
Major documentation improvements
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
Scipy documentation is now more accessible than previously; you can
view a HTML reference manual online at http://docs.scipy.org/ or
@@ -199,7 +196,7 @@
documentation editor at http://docs.scipy.org/ and correct the issues.
Bug fixes in the interpolation package
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------------
The shape of return values from ``scipy.interpolate.interp1d`` used
to be incorrect if interpolated data had more than 2 dimensions and
@@ -212,7 +209,7 @@
if it relies on the incorrect behavior.
Statistics package
-~~~~~~~~~~~~~~~~~~
+------------------
Statistical functions for masked arrays have been added and are accessible
through scipy.stats.mstats. The functions are similar to their counterparts
@@ -237,7 +234,7 @@
release of scipy.
Running Tests
-~~~~~~~~~~~~~
+-------------
NumPy 1.2 introduced a new testing framework based on `nose
`__. Starting with this release SciPy now
@@ -253,13 +250,13 @@
`__.
Building SciPy
-~~~~~~~~~~~~~~
+--------------
Support for NumScons has been added. NumScons is a tentative new
build system for NumPy/SciPy, using scons at its core.
Sandbox Removed
-~~~~~~~~~~~~~~~
+---------------
While porting SciPy to NumPy in 2005, several packages and modules were moved into
``scipy.sandbox``. The sandbox was a staging ground for packages that were undergoing
From scipy-svn at scipy.org Tue Dec 30 14:08:40 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 13:08:40 -0600 (CST)
Subject: [Scipy-svn] r5301 - trunk/scipy/stats
Message-ID: <20081230190840.F41DFC7C00B@scipy.org>
Author: josef
Date: 2008-12-30 13:08:36 -0600 (Tue, 30 Dec 2008)
New Revision: 5301
Modified:
trunk/scipy/stats/stats.py
Log:
fix 2 pvalues that are calculated at the wrong tail
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-30 15:03:59 UTC (rev 5300)
+++ trunk/scipy/stats/stats.py 2008-12-30 19:08:36 UTC (rev 5301)
@@ -886,7 +886,7 @@
alpha = math.sqrt(2.0/(W2-1))
y = np.where(y==0, 1, y)
Z = delta*np.log(y/alpha + np.sqrt((y/alpha)**2+1))
- return Z, (1.0 - zprob(Z))*2
+ return Z, (1.0 - zprob(np.abs(Z)))*2
def kurtosistest(a, axis=0):
@@ -928,7 +928,8 @@
if Z.ndim == 0:
Z = Z[()]
#JPNote: p-value sometimes larger than 1
- return Z, (1.0-zprob(Z))*2
+ #zprob uses upper tail, so Z needs to be positive
+ return Z, (1.0-zprob(np.abs(Z)))*2
def normaltest(a, axis=0):
From scipy-svn at scipy.org Tue Dec 30 18:30:46 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 17:30:46 -0600 (CST)
Subject: [Scipy-svn] r5302 - in trunk: doc/source scipy/fftpack scipy/stats
Message-ID: <20081230233046.A397EC7C00B@scipy.org>
Author: ptvirtan
Date: 2008-12-30 17:30:23 -0600 (Tue, 30 Dec 2008)
New Revision: 5302
Modified:
trunk/doc/source/interpolate.rst
trunk/doc/source/optimize.rst
trunk/doc/source/special.rst
trunk/doc/source/stats.mstats.rst
trunk/doc/source/stats.rst
trunk/scipy/fftpack/basic.py
trunk/scipy/stats/distributions.py
trunk/scipy/stats/info.py
trunk/scipy/stats/stats.py
Log:
Merge from doc wiki
Modified: trunk/doc/source/interpolate.rst
===================================================================
--- trunk/doc/source/interpolate.rst 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/doc/source/interpolate.rst 2008-12-30 23:30:23 UTC (rev 5302)
@@ -39,6 +39,20 @@
InterpolatedUnivariateSpline
LSQUnivariateSpline
+The above univariate spline classes have the following methods:
+
+.. autosummary::
+ :toctree: generated/
+
+ UnivariateSpline.__call__
+ UnivariateSpline.derivatives
+ UnivariateSpline.integral
+ UnivariateSpline.roots
+ UnivariateSpline.get_coeffs
+ UnivariateSpline.get_knots
+ UnivariateSpline.get_residual
+ UnivariateSpline.set_smoothing_factor
+
Low-level interface to FITPACK functions:
.. autosummary::
Modified: trunk/doc/source/optimize.rst
===================================================================
--- trunk/doc/source/optimize.rst 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/doc/source/optimize.rst 2008-12-30 23:30:23 UTC (rev 5302)
@@ -30,6 +30,7 @@
fmin_l_bfgs_b
fmin_tnc
fmin_cobyla
+ nnls
Global
------
Modified: trunk/doc/source/special.rst
===================================================================
--- trunk/doc/source/special.rst 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/doc/source/special.rst 2008-12-30 23:30:23 UTC (rev 5302)
@@ -299,8 +299,18 @@
weights, and total weights for the appropriate form of Gaussian
quadrature. These are returned in an n x 3 array with roots in
the first column, weights in the second column, and total weights
-in the final column
+in the final column.
+.. warning::
+
+ Evaluating large-order polynomials using these functions can be
+ numerically unstable.
+
+ The reason is that the functions below return polynomials as
+ `numpy.poly1d` objects, which represent the polynomial in terms
+ of their coefficients, and this can result to loss of precision
+ when the polynomial terms are summed.
+
.. autosummary::
:toctree: generated/
Modified: trunk/doc/source/stats.mstats.rst
===================================================================
--- trunk/doc/source/stats.mstats.rst 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/doc/source/stats.mstats.rst 2008-12-30 23:30:23 UTC (rev 5302)
@@ -14,69 +14,68 @@
.. autosummary::
:toctree: generated/
-
-argstoarray
-betai
-chisquare
-count_tied_groups
-describe
-f_oneway
-f_value_wilks_lambda
-find_repeats
-friedmanchisquare
-gmean
-hmean
-kendalltau
-kendalltau_seasonal
-kruskalwallis
-kruskalwallis
-ks_twosamp
-ks_twosamp
-kurtosis
-kurtosistest
-linregress
-mannwhitneyu
-plotting_positions
-mode
-moment
-mquantiles
-msign
-normaltest
-obrientransform
-pearsonr
-plotting_positions
-pointbiserialr
-rankdata
-samplestd
-samplevar
-scoreatpercentile
-sem
-signaltonoise
-skew
-skewtest
-spearmanr
-std
-stderr
-theilslopes
-threshold
-tmax
-tmean
-tmin
-trim
-trima
-trimboth
-trimmed_stde
-trimr
-trimtail
-tsem
-ttest_onesamp
-ttest_ind
-ttest_onesamp
-ttest_rel
-tvar
-var
-variation
-winsorize
-z
-zmap
-zs
+ argstoarray
+ betai
+ chisquare
+ count_tied_groups
+ describe
+ f_oneway
+ f_value_wilks_lambda
+ find_repeats
+ friedmanchisquare
+ gmean
+ hmean
+ kendalltau
+ kendalltau_seasonal
+ kruskalwallis
+ kruskalwallis
+ ks_twosamp
+ ks_twosamp
+ kurtosis
+ kurtosistest
+ linregress
+ mannwhitneyu
+ plotting_positions
+ mode
+ moment
+ mquantiles
+ msign
+ normaltest
+ obrientransform
+ pearsonr
+ plotting_positions
+ pointbiserialr
+ rankdata
+ samplestd
+ samplevar
+ scoreatpercentile
+ sem
+ signaltonoise
+ skew
+ skewtest
+ spearmanr
+ std
+ stderr
+ theilslopes
+ threshold
+ tmax
+ tmean
+ tmin
+ trim
+ trima
+ trimboth
+ trimmed_stde
+ trimr
+ trimtail
+ tsem
+ ttest_onesamp
+ ttest_ind
+ ttest_onesamp
+ ttest_rel
+ tvar
+ var
+ variation
+ winsorize
+ z
+ zmap
+ zs
Modified: trunk/doc/source/stats.rst
===================================================================
--- trunk/doc/source/stats.rst 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/doc/source/stats.rst 2008-12-30 23:30:23 UTC (rev 5302)
@@ -143,6 +143,9 @@
Statistical functions
=====================
+Several of these functions have a similar version in scipy.stats.mstats
+which work for masked arrays.
+
.. autosummary::
:toctree: generated/
@@ -261,6 +264,13 @@
ppcc_max
ppcc_plot
+Univariate and multivariate kernel density estimation (:mod:`scipy.stats.kde`)
+==============================================================================
+.. autosummary::
+ :toctree: generated/
+
+ gaussian_kde
+
For many more stat related functions install the software R and the
interface package rpy.
Modified: trunk/scipy/fftpack/basic.py
===================================================================
--- trunk/scipy/fftpack/basic.py 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/scipy/fftpack/basic.py 2008-12-30 23:30:23 UTC (rev 5302)
@@ -55,31 +55,53 @@
def fft(x, n=None, axis=-1, overwrite_x=0):
- """ fft(x, n=None, axis=-1, overwrite_x=0) -> y
-
+ """
Return discrete Fourier transform of arbitrary type sequence x.
- The returned complex array contains
- [y(0),y(1),..,y(n/2-1),y(-n/2),...,y(-1)] if n is even
- [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)] if n is odd
- where
- y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n)
- j = 0..n-1
- Note that y(-j) = y(n-j).
-
- Optional input:
- n
- Defines the length of the Fourier transform. If n is not
- specified then n=x.shape[axis] is set. If nx.shape[axis], x is zero-padded.
- axis
- The transform is applied along the given axis of the input
- array (or the newly constructed array if n argument was used).
- overwrite_x
- If set to true, the contents of x can be destroyed.
+ (Default n=x.shape[axis]).
+ axis : int, optional
+ Axis along which the fft's are computed. (default=-1)
+ overwrite_x : bool, optional
+ If True the contents of x can be destroyed. (default=False)
- Notes:
- y == fft(ifft(y)) within numerical accuracy.
+ Returns
+ -------
+ z : complex ndarray
+ with the elements:
+ [y(0),y(1),..,y(n/2-1),y(-n/2),...,y(-1)] if n is even
+ [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)] if n is odd
+ where
+ y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1
+ Note that y(-j) = y(n-j).
+
+ See Also
+ --------
+ ifft : Inverse FFT
+ rfft : FFT of a real sequence
+
+ Notes
+ -----
+ The packing of the result is "standard": If A = fft(a, n), then A[0]
+ contains the zero-frequency term, A[1:n/2+1] contains the
+ positive-frequency terms, and A[n/2+1:] contains the negative-frequency
+ terms, in order of decreasingly negative frequency. So for an 8-point
+ transform, the frequencies of the result are [ 0, 1, 2, 3, 4, -3, -2, -1].
+
+ This is most efficient for n a power of two.
+
+ Examples
+ --------
+ >>> x = np.arange(5)
+ >>> np.all(np.abs(x-fft(ifft(x))<1.e-15) #within numerical accuracy.
+ True
+
"""
tmp = asarray(x)
if istype(tmp, numpy.complex128):
Modified: trunk/scipy/stats/distributions.py
===================================================================
--- trunk/scipy/stats/distributions.py 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/scipy/stats/distributions.py 2008-12-30 23:30:23 UTC (rev 5302)
@@ -275,18 +275,26 @@
# These are actually called, and should not be overwritten if you
# want to keep error checking.
def rvs(self,*args,**kwds):
- """Random variates of given type.
+ """
+ Random variates of given type.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
+ size : int or tuple of ints, optional
+ defining number of random variates (default=1)
- **kwds
- ======
- size - number of random variates (default=1)
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
+ Returns
+ -------
+ rvs : array-like
+ random variates of given `size`
+
"""
kwd_names = ['loc', 'scale', 'size', 'discrete']
loc, scale, size, discrete = map(kwds.get, kwd_names,
@@ -322,18 +330,17 @@
class rv_continuous(rv_generic):
- """A Generic continuous random variable.
+ """
+ A Generic continuous random variable.
- Continuous random variables are defined from a standard form chosen
- for simplicity of representation. The standard form may require
- some shape parameters to complete its specification. The distributions
- also take optional location and scale parameters using loc= and scale=
- keywords (defaults: loc=0, scale=1)
+ Continuous random variables are defined from a standard form and may
+ require some shape parameters to complete its specification. Any
+ optional keyword parameters can be passed to the methods of the RV
+ object as given below:
- These shape, scale, and location parameters can be passed to any of the
- methods of the RV object such as the following:
-
- generic.rvs(,loc=0,scale=1)
+ Methods
+ -------
+ generic.rvs(,loc=0,scale=1,size=1)
- random variates
generic.pdf(x,,loc=0,scale=1)
@@ -352,18 +359,60 @@
- inverse survival function (inverse of sf)
generic.stats(,loc=0,scale=1,moments='mv')
- - mean('m',axis=0), variance('v'), skew('s'), and/or kurtosis('k')
+ - mean('m'), variance('v'), skew('s'), and/or kurtosis('k')
generic.entropy(,loc=0,scale=1)
- (differential) entropy of the RV.
- Alternatively, the object may be called (as a function) to fix
- the shape, location, and scale parameters returning a
- "frozen" continuous RV object:
+ generic.fit(data,,loc=0,scale=1)
+ - Parameter estimates for generic data
- myrv = generic(,loc=0,scale=1)
- - frozen RV object with the same methods but holding the
- given shape, location, and scale fixed
+ Alternatively, the object may be called (as a function) to fix the shape,
+ location, and scale parameters returning a "frozen" continuous RV object:
+
+ rv = generic(,loc=0,scale=1)
+ - frozen RV object with the same methods but holding the given shape, location, and scale fixed
+
+ Parameters
+ ----------
+ x : array-like
+ quantiles
+ q : array-like
+ lower or upper tail probability
+ : array-like
+ shape parameters
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
+ size : int or tuple of ints, optional
+ shape of random variates (default computed from input arguments )
+ moments : string, optional
+ composed of letters ['mvsk'] specifying which moments to compute where
+ 'm' = mean, 'v' = variance, 's' = (Fisher's) skew and
+ 'k' = (Fisher's) kurtosis. (default='mv')
+
+ Examples
+ --------
+ >>> import matplotlib.pyplot as plt
+ >>> numargs = generic.numargs
+ >>> [ ] = [0.9,]*numargs
+ >>> rv = generic()
+
+ Display frozen pdf
+
+ >>> x = np.linspace(0,np.minimum(rv.dist.b,3))
+ >>> h=plt.plot(x,rv.pdf(x))
+
+ Check accuracy of cdf and ppf
+
+ >>> prb = generic.cdf(x,)
+ >>> h=plt.semilogy(np.abs(x-generic.ppf(prb,c))+1e-20)
+
+ Random number generation
+
+ >>> R = generic.rvs(,size=100)
+
"""
def __init__(self, momtype=1, a=None, b=None, xa=-10.0, xb=10.0,
xtol=1e-14, badvalue=None, name=None, longname=None,
@@ -496,17 +545,26 @@
return self.generic_moment(n,*args)
def pdf(self,x,*args,**kwds):
- """Probability density function at x of the given RV.
+ """
+ Probability density function at x of the given RV.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ x : array-like
+ quantiles
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
- **kwds
- ======
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
+ Returns
+ -------
+ pdf : array-like
+ Probability density function evaluated at x
+
"""
loc,scale=map(kwds.get,['loc','scale'])
args, loc, scale = self._fix_loc_scale(args, loc, scale)
@@ -526,17 +584,26 @@
return output
def cdf(self,x,*args,**kwds):
- """Cumulative distribution function at x of the given RV.
+ """
+ Cumulative distribution function at x of the given RV.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ x : array-like
+ quantiles
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
- **kwds
- ======
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
+ Returns
+ -------
+ cdf : array-like
+ Cumulative distribution function evaluated at x
+
"""
loc,scale=map(kwds.get,['loc','scale'])
args, loc, scale = self._fix_loc_scale(args, loc, scale)
@@ -558,17 +625,26 @@
return output
def sf(self,x,*args,**kwds):
- """Survival function (1-cdf) at x of the given RV.
+ """
+ Survival function (1-cdf) at x of the given RV.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ x : array-like
+ quantiles
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
- **kwds
- ======
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
+ Returns
+ -------
+ sf : array-like
+ Survival function evaluated at x
+
"""
loc,scale=map(kwds.get,['loc','scale'])
args, loc, scale = self._fix_loc_scale(args, loc, scale)
@@ -589,17 +665,26 @@
return output
def ppf(self,q,*args,**kwds):
- """Percent point function (inverse of cdf) at q of the given RV.
+ """
+ Percent point function (inverse of cdf) at q of the given RV.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ q : array-like
+ lower tail probability
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
- **kwds
- ======
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
+ Returns
+ -------
+ x : array-like
+ quantile corresponding to the lower tail probability q.
+
"""
loc,scale=map(kwds.get,['loc','scale'])
args, loc, scale = self._fix_loc_scale(args, loc, scale)
@@ -621,17 +706,26 @@
return output
def isf(self,q,*args,**kwds):
- """Inverse survival function at q of the given RV.
+ """
+ Inverse survival function at q of the given RV.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ q : array-like
+ upper tail probability
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
- **kwds
- ======
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
+ Returns
+ -------
+ x : array-like
+ quantile corresponding to the upper tail probability q.
+
"""
loc,scale=map(kwds.get,['loc','scale'])
args, loc, scale = self._fix_loc_scale(args, loc, scale)
@@ -654,23 +748,32 @@
return output
def stats(self,*args,**kwds):
- """Some statistics of the given RV
+ """
+ Some statistics of the given RV
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
- **kwds
- ======
- loc - location parameter (default=0)
- scale - scale parameter (default=1)
- moments - a string composed of letters ['mvsk'] specifying
- which moments to compute (default='mv')
- 'm' = mean,
- 'v' = variance,
- 's' = (Fisher's) skew,
- 'k' = (Fisher's) kurtosis.
+ moments : string, optional
+ composed of letters ['mvsk'] defining which moments to compute:
+ 'm' = mean,
+ 'v' = variance,
+ 's' = (Fisher's) skew,
+ 'k' = (Fisher's) kurtosis.
+ (default='mv')
+
+ Returns
+ -------
+ stats : sequence
+ of requested moments.
+
"""
loc,scale,moments=map(kwds.get,['loc','scale','moments'])
@@ -767,13 +870,15 @@
return tuple(output)
def moment(self, n, *args):
- """n'th non-central moment of distribution
+ """
+ n'th order non-central moment of distribution
- Parameters:
- -----------
+ Parameters
+ ----------
n: int, n>=1
+ order of moment
- *args:
+ arg1, arg2, arg3,... : array-like
The shape parameter(s) for the distribution (see docstring of the
instance object for more information)
@@ -883,6 +988,21 @@
def entropy(self, *args, **kwds):
+ """
+ Differential entropy of the RV.
+
+
+ Parameters
+ ----------
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ scale : array-like, optional
+ scale parameter (default=1)
+
+ """
loc,scale=map(kwds.get,['loc','scale'])
args, loc, scale = self._fix_loc_scale(args, loc, scale)
args = tuple(map(arr,args))
@@ -3501,15 +3621,16 @@
# x_k, p(x_k) lists in initialization
class rv_discrete(rv_generic):
- """A generic discrete random variable.
+ """
+ A Generic discrete random variable.
- Discrete random variables are defined from a standard form.
- The standard form may require some other parameters to complete
- its specification. The distribution methods also take an optional location
- parameter using loc= keyword. The default is loc=0. The calling form
- of the methods follow:
+ Discrete random variables are defined from a standard form and may require
+ some shape parameters to complete its specification. Any optional keyword
+ parameters can be passed to the methods of the RV object as given below:
- generic.rvs(,loc=0)
+ Methods
+ -------
+ generic.rvs(,loc=0,size=1)
- random variates
generic.pmf(x,,loc=0)
@@ -3534,17 +3655,40 @@
- entropy of the RV
Alternatively, the object may be called (as a function) to fix
- the shape and location parameters returning a
- "frozen" discrete RV object:
+ the shape and location parameters returning a
+ "frozen" discrete RV object:
myrv = generic(,loc=0)
- - frozen RV object with the same methods but holding the
- given shape and location fixed.
+ - frozen RV object with the same methods but holding the given shape and location fixed.
You can construct an aribtrary discrete rv where P{X=xk} = pk
by passing to the rv_discrete initialization method (through the values=
keyword) a tuple of sequences (xk,pk) which describes only those values of
X (xk) that occur with nonzero probability (pk).
+
+ Examples:
+ ---------
+ >>> import matplotlib.pyplot as plt
+ >>> numargs = generic.numargs
+ >>> [ ] = ['Replace with resonable value',]*numargs
+
+ Display frozen pmf:
+ >>> rv = generic()
+ >>> x = np.arange(0,np.min(rv.dist.b,3)+1)
+ >>> h = plt.plot(x,rv.pmf(x))
+
+ Check accuracy of cdf and ppf:
+ >>> prb = generic.cdf(x,)
+ >>> h = plt.semilogy(np.abs(x-generic.ppf(prb,))+1e-20)
+
+ Random number generation:
+ >>> R = generic.rvs(,size=100)
+
+ Custom made discrete distribution:
+ >>> vals = [arange(7),(0.1,0.2,0.3,0.1,0.1,0.1,0.1)]
+ >>> custm = rv_discrete(name='custm',values=vals)
+ >>> h = plt.plot(vals[0],custm.pmf(vals[0]))
+
"""
def __init__(self, a=0, b=inf, name=None, badvalue=None,
moment_tol=1e-8,values=None,inc=1,longname=None,
@@ -3676,20 +3820,48 @@
def rvs(self, *args, **kwargs):
+ """
+ Random variates of given type.
+
+ Parameters
+ ----------
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ size : int or tuple of ints, optional
+ defining number of random variates (default=1)
+
+ Returns
+ -------
+ rvs : array-like
+ random variates of given `size`
+
+ """
kwargs['discrete'] = True
return rv_generic.rvs(self, *args, **kwargs)
def pmf(self, k,*args, **kwds):
- """Probability mass function at k of the given RV.
+ """
+ Probability mass function at k of the given RV.
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
- **kwds
- ======
- loc - location parameter (default=0)
+ Parameters
+ ----------
+ k : array-like
+ quantiles
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+
+ Returns
+ -------
+ pmf : array-like
+ Probability mass function evaluated at k
+
"""
loc = kwds.get('loc')
args, loc = self._fix_loc(args, loc)
@@ -3708,16 +3880,24 @@
return output
def cdf(self, k, *args, **kwds):
- """Cumulative distribution function at k of the given RV
+ """
+ Cumulative distribution function at k of the given RV
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ k : array-like, int
+ quantiles
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
- **kwds
- ======
- loc - location parameter (default=0)
+ Returns
+ -------
+ cdf : array-like
+ Cumulative distribution function evaluated at k
+
"""
loc = kwds.get('loc')
args, loc = self._fix_loc(args, loc)
@@ -3740,16 +3920,24 @@
return output
def sf(self,k,*args,**kwds):
- """Survival function (1-cdf) at k of the given RV
+ """
+ Survival function (1-cdf) at k of the given RV
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ k : array-like
+ quantiles
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
- **kwds
- ======
- loc - location parameter (default=0)
+ Returns
+ -------
+ sf : array-like
+ Survival function evaluated at k
+
"""
loc= kwds.get('loc')
args, loc = self._fix_loc(args, loc)
@@ -3770,16 +3958,24 @@
return output
def ppf(self,q,*args,**kwds):
- """Percent point function (inverse of cdf) at q of the given RV
+ """
+ Percent point function (inverse of cdf) at q of the given RV
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ q : array-like
+ lower tail probability
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
- **kwds
- ======
- loc - location parameter (default=0)
+ Returns
+ -------
+ k : array-like
+ quantile corresponding to the lower tail probability, q.
+
"""
loc = kwds.get('loc')
args, loc = self._fix_loc(args, loc)
@@ -3803,16 +3999,24 @@
return output
def isf(self,q,*args,**kwds):
- """Inverse survival function (1-sf) at q of the given RV
+ """
+ Inverse survival function (1-sf) at q of the given RV
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ q : array-like
+ upper tail probability
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
- **kwds
- ======
- loc - location parameter (default=0)
+ Returns
+ -------
+ k : array-like
+ quantile corresponding to the upper tail probability, q.
+
"""
loc = kwds.get('loc')
@@ -3847,22 +4051,29 @@
return output
def stats(self, *args, **kwds):
- """Some statistics of the given discrete RV
+ """
+ Some statistics of the given discrete RV
- *args
- =====
- The shape parameter(s) for the distribution (see docstring of the
- instance object for more information)
+ Parameters
+ ----------
+ arg1, arg2, arg3,... : array-like
+ The shape parameter(s) for the distribution (see docstring of the
+ instance object for more information)
+ loc : array-like, optional
+ location parameter (default=0)
+ moments : string, optional
+ composed of letters ['mvsk'] defining which moments to compute:
+ 'm' = mean,
+ 'v' = variance,
+ 's' = (Fisher's) skew,
+ 'k' = (Fisher's) kurtosis.
+ (default='mv')
- **kwds
- ======
- loc - location parameter (default=0)
- moments - a string composed of letters ['mvsk'] specifying
- which moments to compute (default='mv')
- 'm' = mean,
- 'v' = variance,
- 's' = (Fisher's) skew,
- 'k' = (Fisher's) kurtosis.
+ Returns
+ -------
+ stats : sequence
+ of requested moments.
+
"""
loc,moments=map(kwds.get,['loc','moments'])
N = len(args)
@@ -3949,14 +4160,14 @@
return tuple(output)
def moment(self, n, *args, **kwds): # Non-central moments in standard form.
- """n'th non-central moment of the distribution
+ """
+ n'th non-central moment of the distribution
-
- Parameters:
- -----------
+ Parameters
+ ----------
n: int, n>=1
-
- *args:
+ order of moment
+ arg1, arg2, arg3,...: array-like
The shape parameter(s) for the distribution (see docstring of the
instance object for more information)
Modified: trunk/scipy/stats/info.py
===================================================================
--- trunk/scipy/stats/info.py 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/scipy/stats/info.py 2008-12-30 23:30:23 UTC (rev 5302)
@@ -9,213 +9,247 @@
For each given name the following methods are available. See docstring for
rv_continuous for more information
-rvs -- random variates with the distribution
-pdf -- probability density function
-cdf -- cummulative distribution function
-sf -- survival function (1.0 - cdf)
-ppf -- percent-point function (inverse of cdf)
-isf -- inverse survival function
-stats -- mean, variance, and optionally skew and kurtosis
+:rvs:
+ random variates with the distribution
+:pdf:
+ probability density function
+:cdf:
+ cumulative distribution function
+:sf:
+ survival function (1.0 - cdf)
+:ppf:
+ percent-point function (inverse of cdf)
+:isf:
+ inverse survival function
+:stats:
+ mean, variance, and optionally skew and kurtosis
Calling the instance as a function returns a frozen pdf whose shape,
location, and scale parameters are fixed.
+Distributions
+---------------
+
The distributions available with the above methods are:
-CONTINUOUS (Total == 81 distributions)
-===========
-norm -- Normal (Gaussian)
-alpha -- Alpha
-anglit -- Anglit
-arcsine -- Arcsine
-beta -- Beta
-betaprime -- Beta Prime
-bradford -- Bradford
-burr -- Burr
-fisk -- Fisk
-cauchy -- Cauchy
-chi -- Chi
-chi2 -- Chi-squared
-cosine -- Cosine
-dgamma -- Double Gamma
-dweibull -- Double Weibull
-erlang -- Erlang
-expon -- Exponential
-exponweib -- Exponentiated Weibull
-exponpow -- Exponential Power
-fatiguelife -- Fatigue Life (Birnbaum-Sanders)
-foldcauchy -- Folded Cauchy
-f -- F (Snecdor F)
-foldnorm -- Folded Normal
-frechet_r -- Frechet Right Sided, Extreme Value Type II (Extreme LB) or weibull_min
-frechet_l -- Frechet Left Sided, Weibull_max
-genlogistic -- Generalized Logistic
-genpareto -- Generalized Pareto
-genexpon -- Generalized Exponential
-genextreme -- Generalized Extreme Value
-gausshyper -- Gauss Hypergeometric
-gamma -- Gamma
-gengamma -- Generalized gamma
-genhalflogistic -- Generalized Half Logistic
-gompertz -- Gompertz (Truncated Gumbel)
-gumbel_r -- Right Sided Gumbel, Log-Weibull, Fisher-Tippett, Extreme Value Type I
-gumbel_l -- Left Sided Gumbel, etc.
-halfcauchy -- Half Cauchy
-halflogistic -- Half Logistic
-halfnorm -- Half Normal
-hypsecant -- Hyperbolic Secant
-invgamma -- Inverse Gamma
-invnorm -- Inverse Normal
-invweibull -- Inverse Weibull
-johnsonsb -- Johnson SB
-johnsonsu -- Johnson SU
-laplace -- Laplace
-logistic -- Logistic
-loggamma -- Log-Gamma
-loglaplace -- Log-Laplace (Log Double Exponential)
-lognorm -- Log-Normal
-gilbrat -- Gilbrat
-lomax -- Lomax (Pareto of the second kind)
-maxwell -- Maxwell
-mielke -- Mielke's Beta-Kappa
-nakagami -- Nakagami
-ncx2 -- Non-central chi-squared
-ncf -- Non-central F
-t -- Student's T
-nct -- Non-central Student's T
-pareto -- Pareto
-powerlaw -- Power-function
-powerlognorm -- Power log normal
-powernorm -- Power normal
-rdist -- R distribution
-reciprocal -- Reciprocal
-rayleigh -- Rayleigh
-rice -- Rice
-recipinvgauss -- Reciprocal Inverse Gaussian
-semicircular -- Semicircular
-triang -- Triangular
-truncexpon -- Truncated Exponential
-truncnorm -- Truncated Normal
-tukeylambda -- Tukey-Lambda
-uniform -- Uniform
-von_mises -- Von-Mises (Circular)
-wald -- Wald
-weibull_min -- Minimum Weibull (see Frechet)
-weibull_max -- Maximum Weibull (see Frechet)
-wrapcauchy -- Wrapped Cauchy
-ksone -- Kolmogorov-Smirnov one-sided (no stats)
-kstwobign -- Kolmogorov-Smirnov two-sided test for Large N (no stats)
+=============== ==============================================================
+Continuous (Total == 81 distributions)
+==============================================================================
+norm Normal (Gaussian)
+alpha Alpha
+anglit Anglit
+arcsine Arcsine
+beta Beta
+betaprime Beta Prime
+bradford Bradford
+burr Burr
+fisk Fisk
+cauchy Cauchy
+chi Chi
+chi2 Chi-squared
+cosine Cosine
+dgamma Double Gamma
+dweibull Double Weibull
+erlang Erlang
+expon Exponential
+exponweib Exponentiated Weibull
+exponpow Exponential Power
+fatiguelife Fatigue Life (Birnbaum-Sanders)
+foldcauchy Folded Cauchy
+f F (Snecdor F)
+foldnorm Folded Normal
+frechet_r Frechet Right Sided, Extreme Value Type II (Extreme LB) or weibull_min
+frechet_l Frechet Left Sided, Weibull_max
+genlogistic Generalized Logistic
+genpareto Generalized Pareto
+genexpon Generalized Exponential
+genextreme Generalized Extreme Value
+gausshyper Gauss Hypergeometric
+gamma Gamma
+gengamma Generalized gamma
+genhalflogistic Generalized Half Logistic
+gompertz Gompertz (Truncated Gumbel)
+gumbel_r Right Sided Gumbel, Log-Weibull, Fisher-Tippett, Extreme Value Type I
+gumbel_l Left Sided Gumbel, etc.
+halfcauchy Half Cauchy
+halflogistic Half Logistic
+halfnorm Half Normal
+hypsecant Hyperbolic Secant
+invgamma Inverse Gamma
+invnorm Inverse Normal
+invweibull Inverse Weibull
+johnsonsb Johnson SB
+johnsonsu Johnson SU
+laplace Laplace
+logistic Logistic
+loggamma Log-Gamma
+loglaplace Log-Laplace (Log Double Exponential)
+lognorm Log-Normal
+gilbrat Gilbrat
+lomax Lomax (Pareto of the second kind)
+maxwell Maxwell
+mielke Mielke's Beta-Kappa
+nakagami Nakagami
+ncx2 Non-central chi-squared
+ncf Non-central F
+t Student's T
+nct Non-central Student's T
+pareto Pareto
+powerlaw Power-function
+powerlognorm Power log normal
+powernorm Power normal
+rdist R distribution
+reciprocal Reciprocal
+rayleigh Rayleigh
+rice Rice
+recipinvgauss Reciprocal Inverse Gaussian
+semicircular Semicircular
+triang Triangular
+truncexpon Truncated Exponential
+truncnorm Truncated Normal
+tukeylambda Tukey-Lambda
+uniform Uniform
+von_mises Von-Mises (Circular)
+wald Wald
+weibull_min Minimum Weibull (see Frechet)
+weibull_max Maximum Weibull (see Frechet)
+wrapcauchy Wrapped Cauchy
+ksone Kolmogorov-Smirnov one-sided (no stats)
+kstwobign Kolmogorov-Smirnov two-sided test for Large N (no stats)
+=============== ==============================================================
-DISCRETE (Total == 10 distributions)
-============
-binom -- Binomial
-bernoulli -- Bernoulli
-nbinom -- Negative Binomial
-geom -- Geometric
-hypergeom -- Hypergeometric
-logser -- Logarithmic (Log-Series, Series)
-poisson -- Poisson
-planck -- Planck (Discrete Exponential)
-boltzmann -- Boltzmann (Truncated Discrete Exponential)
-randint -- Discrete Uniform
-zipf -- Zipf
-dlaplace -- Discrete Laplacian
+=============== ==============================================================
+Discrete (Total == 10 distributions)
+==============================================================================
+binom Binomial
+bernoulli Bernoulli
+nbinom Negative Binomial
+geom Geometric
+hypergeom Hypergeometric
+logser Logarithmic (Log-Series, Series)
+poisson Poisson
+planck Planck (Discrete Exponential)
+boltzmann Boltzmann (Truncated Discrete Exponential)
+randint Discrete Uniform
+zipf Zipf
+dlaplace Discrete Laplacian
+=============== ==============================================================
Statistical Functions (adapted from Gary Strangman)
+-----------------------------------------------------
-gmean -- _
-hmean -- _
-mean -- _
-cmedian -- _
-median -- _
-mode -- _
-tmean -- _
-tvar -- _
-tmin -- _
-tmax -- _
-tstd -- _
-tsem -- _
-moment -- _
-variation -- _
-skew -- _
-kurtosis -- _
-describe -- _
-skewtest -- _
-kurtosistest -- _
-normaltest -- _
+================= ==============================================================
+gmean Geometric mean
+hmean Harmonic mean
+mean Arithmetic mean
+cmedian Computed median
+median Median
+mode Modal value
+tmean Truncated arithmetic mean
+tvar Truncated variance
+tmin _
+tmax _
+tstd _
+tsem _
+moment Central moment
+variation Coefficient of variation
+skew Skewness
+kurtosis Fisher or Pearson kurtosis
+describe Descriptive statistics
+skewtest _
+kurtosistest _
+normaltest _
+================= ==============================================================
-itemfreq -- _
-scoreatpercentile -- _
-percentileofscore -- _
-histogram2 -- _
-histogram -- _
-cumfreq -- _
-relfreq -- _
+================= ==============================================================
+itemfreq _
+scoreatpercentile _
+percentileofscore _
+histogram2 _
+histogram _
+cumfreq _
+relfreq _
+================= ==============================================================
-obrientransform -- _
-samplevar -- _
-samplestd -- _
-signaltonoise -- _
-bayes_mvs -- _
-var -- _
-std -- _
-stderr -- _
-sem -- _
-z -- _
-zs -- _
-zmap -- _
+================= ==============================================================
+obrientransform _
+samplevar _
+samplestd _
+signaltonoise _
+bayes_mvs _
+var _
+std _
+stderr _
+sem _
+z _
+zs _
+zmap _
+================= ==============================================================
-threshold -- _
-trimboth -- _
-trim1 -- _
-cov -- _
-corrcoef -- _
+================= ==============================================================
+threshold _
+trimboth _
+trim1 _
+cov _
+corrcoef _
+================= ==============================================================
-f_oneway -- _
-paired -- _
-pearsonr -- _
-spearmanr -- _
-pointbiserialr -- _
-kendalltau -- _
-linregress -- _
+================= ==============================================================
+f_oneway _
+paired _
+pearsonr _
+spearmanr _
+pointbiserialr _
+kendalltau _
+linregress _
+================= ==============================================================
-ttest_1samp -- _
-ttest_ind -- _
-ttest_rel -- _
-kstest -- _
-chisquare -- _
-ks_2samp -- _
-meanwhitneyu -- _
-tiecorrect -- _
-ranksums -- _
-wilcoxon -- _
-kruskal -- _
-friedmanchisquare -- _
+================= ==============================================================
+ttest_1samp _
+ttest_ind _
+ttest_rel _
+kstest _
+chisquare _
+ks_2samp _
+meanwhitneyu _
+tiecorrect _
+ranksums _
+wilcoxon _
+kruskal _
+friedmanchisquare _
+================= ==============================================================
-ansari -- _
-bartlett -- _
-levene -- _
-shapiro -- _
-anderson -- _
-binom_test -- _
-fligner -- _
-mood -- _
-oneway -- _
+================= ==============================================================
+ansari _
+bartlett _
+levene _
+shapiro _
+anderson _
+binom_test _
+fligner _
+mood _
+oneway _
+================= ==============================================================
+================= ==============================================================
+glm _
+anova _
+================= ==============================================================
-glm -- _
-anova -- _
+================= ==============================================================
Plot-tests
+================================================================================
+probplot _
+ppcc_max _
+ppcc_plot _
+================= ==============================================================
-probplot -- _
-ppcc_max -- _
-ppcc_plot -- _
-
For many more stat related functions install the software R and the
interface package rpy.
+
"""
postpone_import = 1
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-30 19:08:36 UTC (rev 5301)
+++ trunk/scipy/stats/stats.py 2008-12-30 23:30:23 UTC (rev 5302)
@@ -2136,7 +2136,8 @@
#import scipy.stats
#import distributions
def kstest(rvs, cdf, args=(), N=20, alternative = 'two_sided', mode='approx',**kwds):
- """Return the D-value and the p-value for a Kolmogorov-Smirnov test
+ """
+ Return the D-value and the p-value for a Kolmogorov-Smirnov test
This performs a test of the distribution G(x) of an observed
random variable against a given distribution F(x). Under the null
@@ -2151,14 +2152,12 @@
array: 1-D observations of random variables
- callable: function to generate random variables,
- requires keyword argument `size`
+ callable: function to generate random variables, requires keyword
+ argument `size`
cdf : string or callable
- string: name of a distribution in scipy.stats
- if rvs is a string then cdf can evaluate to False
- or be the same as rvs
-
+ string: name of a distribution in scipy.stats, if rvs is a string then
+ cdf can evaluate to `False` or be the same as rvs
callable: function to evaluate cdf
args : tuple, sequence
@@ -2167,6 +2166,7 @@
sample size if rvs is string or callable
alternative : 'two_sided' (default), 'less' or 'greater'
defines the alternative hypothesis (see explanation)
+
mode : 'approx' (default) or 'asymp'
defines the distribution used for calculating p-value
@@ -2205,8 +2205,7 @@
>>> kstest(x,'norm')
(0.44435602715924361, 0.038850142705171065)
- >>> #fix random seed to get the same result
- >>> np.random.seed(987654321)
+ >>> np.random.seed(987654321) # set random seed to get the same result
>>> kstest('norm','',N=100)
(0.058352892479417884, 0.88531190944151261)
@@ -2216,22 +2215,28 @@
>>> kstest(stats.norm.rvs(size=100),'norm')
(0.058352892479417884, 0.88531190944151261)
- **test against one-sided alternative hypothesis**
+ Test against one-sided alternative hypothesis:
>>> np.random.seed(987654321)
- >>> #shift distribution to larger values, so that cdf_dgp(x)< norm.cdf(x)
- >>> x = stats.norm.rvs(loc=0.2, size=100)
- >>> kstest(x,'norm', alternative = 'less')
+
+ Shift distribution to larger values, so that cdf_dgp(x)< norm.cdf(x):
+
+ >>> x = stats.norm.rvs(loc=0.2, size=100)
+ >>> kstest(x,'norm', alternative = 'less')
(0.12464329735846891, 0.040989164077641749)
- >>> #reject equal distribution against alternative hypothesis: less
+
+ Reject equal distribution against alternative hypothesis: less
+
>>> kstest(x,'norm', alternative = 'greater')
(0.0072115233216311081, 0.98531158590396395)
- >>> #don't reject equal distribution against alternative hypothesis: greater
+
+ Don't reject equal distribution against alternative hypothesis: greater
+
>>> kstest(x,'norm', mode='asymp')
(0.12464329735846891, 0.08944488871182088)
- **testing t distributed random variables against normal distribution**
+ Testing t distributed random variables against normal distribution:
With 100 degrees of freedom the t distribution looks close to the normal
distribution, and the kstest does not reject the hypothesis that the sample
From scipy-svn at scipy.org Tue Dec 30 18:54:54 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 17:54:54 -0600 (CST)
Subject: [Scipy-svn] r5303 - trunk/scipy/io/matlab
Message-ID: <20081230235454.E2C40C7C00B@scipy.org>
Author: matthew.brett at gmail.com
Date: 2008-12-30 17:54:50 -0600 (Tue, 30 Dec 2008)
New Revision: 5303
Added:
trunk/scipy/io/matlab/gzipstreams.py
Modified:
trunk/scipy/io/matlab/mio5.py
trunk/scipy/io/matlab/miobase.py
Log:
Fixed bug reading empty strings; added theoretically more satisfying as-needed gzip stream reader for compressed arrays
Added: trunk/scipy/io/matlab/gzipstreams.py
===================================================================
--- trunk/scipy/io/matlab/gzipstreams.py 2008-12-30 23:30:23 UTC (rev 5302)
+++ trunk/scipy/io/matlab/gzipstreams.py 2008-12-30 23:54:50 UTC (rev 5303)
@@ -0,0 +1,220 @@
+''' Object for reading from gzipped file-like object
+
+Edited by Matthew Brett, with thanks, from
+http://effbot.org/librarybook/zlib-example-4.py
+
+The copyright and license for that code is:
+
+Copyright 1995-2008 by Fredrik Lundh
+
+By obtaining, using, and/or copying this software and/or its
+associated documentation, you agree that you have read, understood,
+and will comply with the following terms and conditions:
+
+Permission to use, copy, modify, and distribute this software and its
+associated documentation for any purpose and without fee is hereby
+granted, provided that the above copyright notice appears in all
+copies, and that both that copyright notice and this permission notice
+appear in supporting documentation, and that the name of Secret Labs
+AB or the author not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+'''
+
+from zlib import decompressobj
+
+
+class GzipInputStream(object):
+ ''' Fileobject to wrap zlib compressed stream for reading
+
+ >>> from StringIO import StringIO
+ >>> from zlib import compress
+ >>> S = 'A handy module for reading compressed streams'
+ >>> F = StringIO(compress(S))
+ >>> ZF = GzipInputStream(F)
+ >>> ZF.read()
+ 'A handy module for reading compressed streams'
+ >>> ZF.tell() == len(S)
+ True
+ >>> F = StringIO(compress(S))
+ >>> ZF = GzipInputStream(F)
+ >>> ZF.tell()
+ 0
+ >>> ZF.read(6)
+ 'A hand'
+ >>> ZF.tell()
+ 6
+ >>> F = StringIO(compress(S))
+ >>> ZF = GzipInputStream(F, 6) # with length
+ >>> ZF.read()
+ 'A hand'
+ >>> ZF.read()
+ ''
+ >>> ZF.tell()
+ 6
+ >>>
+ '''
+
+ blocksize = 16384 # 16K
+ def __init__(self, fileobj, length=None):
+ ''' Initialize GzipInputStream
+
+ Parameters
+ ----------
+ fileobj : file-like object
+ Object only need implement ``read`` method
+ length : None or int, optional
+ Uncompressed length of input stream in bytes
+ '''
+ self.fileobj = fileobj
+ self.length=length
+ self.exhausted = False
+ self.unzipped_pos = 0
+ self.data = ""
+ self._unzipper = decompressobj()
+ self._bytes_read = 0
+
+ def __fill(self, bytes):
+ ''' Fill self.data with at least *bytes* number of bytes
+ If bytes == -1, continue until the end of the stream
+
+ Returns ``None``
+ '''
+ if self.exhausted:
+ return
+ # read until we have enough bytes in the buffer
+ read_to_end = bytes == -1
+ n_to_fetch = self.blocksize
+ while read_to_end or len(self.data) < bytes:
+ if self.length: # do not read beyond specified length
+ n_to_fetch = min(self.length-self._bytes_read,
+ self.blocksize)
+ if n_to_fetch == 0:
+ self.exhausted = True
+ break
+ data = self.fileobj.read(n_to_fetch)
+ if data:
+ self.__add_data(self._unzipper.decompress(data))
+ if len(data) < n_to_fetch: # hit end of file
+ self.__add_data(self._unzipper.flush())
+ self.exhausted = True
+ break
+
+ def __add_data(self, data):
+ self.data += data
+ self._bytes_read += len(data)
+
+ def seek(self, offset, whence=0):
+ ''' Set position in uncompressed stream
+
+ Parameters
+ ----------
+ offset : int
+ byte offset relative to position given by *whence*
+ offsets are in terms of uncompressed bytes from stream
+ whence : {0,1}
+ 0 signifies *offset* is relative to beginning of file
+ 1 means *offset* is relative to current position
+
+ Returns
+ -------
+ None
+ '''
+ if whence == 0:
+ position = offset
+ elif whence == 1:
+ position = self.unzipped_pos + offset
+ else:
+ raise IOError, "Illegal argument"
+ if position < self.unzipped_pos:
+ raise IOError, "Cannot seek backwards"
+
+ # skip forward, in blocks
+ while position > self.unzipped_pos:
+ if not self.read(min(position - self.unzipped_pos,
+ self.blocksize)):
+ break
+
+ def tell(self):
+ ''' Return current position in terms of uncompressed bytes '''
+ return self.unzipped_pos
+
+ def read(self, bytes = -1):
+ ''' Read bytes from file
+
+ Parameters
+ ----------
+ bytes : int, optional
+ If *bytes* is a positive integer, read this many bytes
+ from file. If *bytes* == -1 (the default), read all bytes
+ to the end of file, where the end of the file is detected
+ by running out of read data, or by the ``length``
+ attribute.
+
+ Returns
+ -------
+ data : string
+ string containing read data
+
+ '''
+ self.__fill(bytes)
+ if bytes == -1:
+ data = self.data
+ self.data = ""
+ else:
+ data = self.data[:bytes]
+ self.data = self.data[bytes:]
+ self.unzipped_pos += len(data)
+ return data
+
+ def readline(self):
+ ''' Read text line from data
+
+ Examples
+ --------
+ >>> from StringIO import StringIO
+ >>> from zlib import compress
+ >>> S = 'A handy module\\nfor reading\\ncompressed streams'
+ >>> F = StringIO(compress(S))
+ >>> ZF = GzipInputStream(F)
+ >>> ZF.readline()
+ 'A handy module\\n'
+ >>> ZF.readline()
+ 'for reading\\n'
+ '''
+ # make sure we have an entire line
+ while not self.exhausted and "\n" not in self.data:
+ self.__fill(len(self.data) + 512)
+ i = self.data.find("\n") + 1
+ if i <= 0:
+ return self.read()
+ return self.read(i)
+
+ def readlines(self):
+ ''' Read all data broken up into list of text lines
+ >>> from StringIO import StringIO
+ >>> from zlib import compress
+ >>> S = 'A handy module\\nfor reading\\ncompressed streams'
+ >>> F = StringIO(compress(S))
+ >>> ZF = GzipInputStream(F)
+ >>> ZF.readlines()
+ ['A handy module\\n', 'for reading\\n', 'compressed streams']
+ >>>
+ '''
+ lines = []
+ while 1:
+ s = self.readline()
+ if not s:
+ break
+ lines.append(s)
+ return lines
+
Modified: trunk/scipy/io/matlab/mio5.py
===================================================================
--- trunk/scipy/io/matlab/mio5.py 2008-12-30 23:30:23 UTC (rev 5302)
+++ trunk/scipy/io/matlab/mio5.py 2008-12-30 23:54:50 UTC (rev 5303)
@@ -12,6 +12,7 @@
import sys
import zlib
+from gzipstreams import GzipInputStream
from StringIO import StringIO
from copy import copy as pycopy
import warnings
@@ -322,14 +323,12 @@
class Mat5ZArrayReader(Mat5ArrayReader):
''' Getter for compressed arrays
- Reads and uncompresses gzipped stream on init, providing wrapper
+ Sets up reader for gzipped stream on init, providing wrapper
for this new sub-stream.
'''
def __init__(self, array_reader, byte_count):
- '''Reads and uncompresses gzipped stream'''
- data = array_reader.mat_stream.read(byte_count)
super(Mat5ZArrayReader, self).__init__(
- StringIO(zlib.decompress(data)),
+ GzipInputStream(array_reader.mat_stream, byte_count),
array_reader.dtypes,
array_reader.processor_func,
array_reader.codecs,
Modified: trunk/scipy/io/matlab/miobase.py
===================================================================
--- trunk/scipy/io/matlab/miobase.py 2008-12-30 23:30:23 UTC (rev 5302)
+++ trunk/scipy/io/matlab/miobase.py 2008-12-30 23:54:50 UTC (rev 5303)
@@ -308,12 +308,13 @@
# Convert char array to string or array of strings
dims = arr.shape
if len(dims) >= 2: # return array of strings
- dtt = self.order_code + 'U'
n_dims = dims[:-1]
+ last_dim = dims[-1]
str_arr = arr.reshape(
(small_product(n_dims),
- dims[-1]))
- arr = np.empty(n_dims, dtype='U%d' % dims[-1])
+ last_dim))
+ dtstr = 'U%d' % (last_dim and last_dim or 1)
+ arr = np.empty(n_dims, dtype=dtstr)
for i in range(0, n_dims[-1]):
arr[...,i] = self.chars_to_str(str_arr[i])
else: # return string
From scipy-svn at scipy.org Tue Dec 30 19:11:46 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 18:11:46 -0600 (CST)
Subject: [Scipy-svn] r5304 - trunk/scipy/stats
Message-ID: <20081231001146.BF9D4C7C00B@scipy.org>
Author: ptvirtan
Date: 2008-12-30 18:11:29 -0600 (Tue, 30 Dec 2008)
New Revision: 5304
Modified:
trunk/scipy/stats/distributions.py
Log:
Fix scipy.stats distribution extradoc indentation levels
Modified: trunk/scipy/stats/distributions.py
===================================================================
--- trunk/scipy/stats/distributions.py 2008-12-30 23:54:50 UTC (rev 5303)
+++ trunk/scipy/stats/distributions.py 2008-12-31 00:11:29 UTC (rev 5304)
@@ -25,6 +25,7 @@
from scipy.special import gammaln as gamln
from copy import copy
import vonmises_cython
+import textwrap
__all__ = [
'rv_continuous',
@@ -394,6 +395,7 @@
Examples
--------
+
>>> import matplotlib.pyplot as plt
>>> numargs = generic.numargs
>>> [ ] = [0.9,]*numargs
@@ -469,6 +471,7 @@
if self.__doc__ is None:
self.__doc__ = rv_continuous.__doc__
if self.__doc__ is not None:
+ self.__doc__ = textwrap.dedent(self.__doc__)
if longname is not None:
self.__doc__ = self.__doc__.replace("A Generic",longname)
if name is not None:
@@ -478,7 +481,7 @@
else:
self.__doc__ = self.__doc__.replace("",shapes)
if extradoc is not None:
- self.__doc__ = self.__doc__ + extradoc
+ self.__doc__ += textwrap.dedent(extradoc)
def _ppf_to_solve(self, x, q,*args):
return apply(self.cdf, (x, )+args)-q
@@ -3666,29 +3669,34 @@
keyword) a tuple of sequences (xk,pk) which describes only those values of
X (xk) that occur with nonzero probability (pk).
- Examples:
- ---------
- >>> import matplotlib.pyplot as plt
- >>> numargs = generic.numargs
- >>> [ ] = ['Replace with resonable value',]*numargs
+ Examples
+ --------
+ >>> import matplotlib.pyplot as plt
+ >>> numargs = generic.numargs
+ >>> [ ] = ['Replace with resonable value',]*numargs
+
Display frozen pmf:
- >>> rv = generic()
- >>> x = np.arange(0,np.min(rv.dist.b,3)+1)
- >>> h = plt.plot(x,rv.pmf(x))
+ >>> rv = generic()
+ >>> x = np.arange(0,np.min(rv.dist.b,3)+1)
+ >>> h = plt.plot(x,rv.pmf(x))
+
Check accuracy of cdf and ppf:
- >>> prb = generic.cdf(x,)
- >>> h = plt.semilogy(np.abs(x-generic.ppf(prb,))+1e-20)
+ >>> prb = generic.cdf(x,)
+ >>> h = plt.semilogy(np.abs(x-generic.ppf(prb,))+1e-20)
+
Random number generation:
- >>> R = generic.rvs(,size=100)
+ >>> R = generic.rvs(,size=100)
+
Custom made discrete distribution:
- >>> vals = [arange(7),(0.1,0.2,0.3,0.1,0.1,0.1,0.1)]
- >>> custm = rv_discrete(name='custm',values=vals)
- >>> h = plt.plot(vals[0],custm.pmf(vals[0]))
+ >>> vals = [arange(7),(0.1,0.2,0.3,0.1,0.1,0.1,0.1)]
+ >>> custm = rv_discrete(name='custm',values=vals)
+ >>> h = plt.plot(vals[0],custm.pmf(vals[0]))
+
"""
def __init__(self, a=0, b=inf, name=None, badvalue=None,
moment_tol=1e-8,values=None,inc=1,longname=None,
@@ -3768,6 +3776,7 @@
if self.__doc__ is None:
self.__doc__ = rv_discrete.__doc__
if self.__doc__ is not None:
+ self.__doc__ = textwrap.dedent(self.__doc__)
self.__doc__ = self.__doc__.replace("A Generic",longname)
if name is not None:
self.__doc__ = self.__doc__.replace("generic",name)
@@ -3778,7 +3787,7 @@
ind = self.__doc__.find("You can construct an arbitrary")
self.__doc__ = self.__doc__[:ind].strip()
if extradoc is not None:
- self.__doc__ = self.__doc__ + extradoc
+ self.__doc__ += textwrap.dedent(extradoc)
def _rvs(self, *args):
return self._ppf(mtrand.random_sample(self._size),*args)
From scipy-svn at scipy.org Tue Dec 30 19:38:00 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Tue, 30 Dec 2008 18:38:00 -0600 (CST)
Subject: [Scipy-svn] r5305 - trunk/doc/source
Message-ID: <20081231003800.78677C7C00B@scipy.org>
Author: ptvirtan
Date: 2008-12-30 18:37:32 -0600 (Tue, 30 Dec 2008)
New Revision: 5305
Modified:
trunk/doc/source/stats.rst
Log:
Link stats.mstats.rst to documentation
Modified: trunk/doc/source/stats.rst
===================================================================
--- trunk/doc/source/stats.rst 2008-12-31 00:11:29 UTC (rev 5304)
+++ trunk/doc/source/stats.rst 2008-12-31 00:37:32 UTC (rev 5305)
@@ -33,6 +33,14 @@
rv_discrete.isf
rv_discrete.stats
+
+Masked statistics functions
+===========================
+
+.. toctree::
+
+ stats.mstats
+
Continuous distributions
========================
From scipy-svn at scipy.org Wed Dec 31 02:05:49 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 01:05:49 -0600 (CST)
Subject: [Scipy-svn] r5306 - trunk/doc/release
Message-ID: <20081231070549.33D19C7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 01:02:20 -0600 (Wed, 31 Dec 2008)
New Revision: 5306
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
minor fixes to release notes
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-31 00:37:32 UTC (rev 5305)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-31 07:02:20 UTC (rev 5306)
@@ -249,12 +249,22 @@
For more information, please see `The NumPy/SciPy Testing Guide
`__.
+We have also greatly improved our test coverage. There were just over 2,000 unit tests in
+the 0.6.0 release; this release nearly doubles that number with just under 4,000 unit tests.
+
Building SciPy
--------------
Support for NumScons has been added. NumScons is a tentative new
-build system for NumPy/SciPy, using scons at its core.
+build system for NumPy/SciPy, using `SCons `__ at its core.
+SCons is a next-generation build system meant to replace the venerable ``Make`` with
+the integrated functionality of ``autoconf``/``automake`` and ``ccache``. Scons is
+written in Python and its configuration files are Python scripts. NumScons is meant
+to replace NumPy's custom version of ``distutils`` providing more advanced functionality
+such as autoconf, improved fortran support, more tools, and support for
+``numpy.distutils``/``scons`` cooperation.
+
Sandbox Removed
---------------
From scipy-svn at scipy.org Wed Dec 31 02:13:07 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 01:13:07 -0600 (CST)
Subject: [Scipy-svn] r5307 - in trunk/scipy: io/matlab ndimage ndimage/tests
signal/tests stats stats/tests
Message-ID: <20081231071307.B71EAC7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 01:13:05 -0600 (Wed, 31 Dec 2008)
New Revision: 5307
Modified:
trunk/scipy/io/matlab/gzipstreams.py
trunk/scipy/io/matlab/mio5.py
trunk/scipy/ndimage/doccer.py
trunk/scipy/ndimage/filters.py
trunk/scipy/ndimage/tests/test_doccer.py
trunk/scipy/signal/tests/test_signaltools.py
trunk/scipy/stats/stats.py
trunk/scipy/stats/tests/test_stats.py
Log:
ran reindent
Modified: trunk/scipy/io/matlab/gzipstreams.py
===================================================================
--- trunk/scipy/io/matlab/gzipstreams.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/io/matlab/gzipstreams.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -61,9 +61,9 @@
''
>>> ZF.tell()
6
- >>>
+ >>>
'''
-
+
blocksize = 16384 # 16K
def __init__(self, fileobj, length=None):
''' Initialize GzipInputStream
@@ -164,7 +164,7 @@
-------
data : string
string containing read data
-
+
'''
self.__fill(bytes)
if bytes == -1:
@@ -217,4 +217,3 @@
break
lines.append(s)
return lines
-
Modified: trunk/scipy/io/matlab/mio5.py
===================================================================
--- trunk/scipy/io/matlab/mio5.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/io/matlab/mio5.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -799,7 +799,7 @@
def write(self):
self.write_header()
self._write_items()
-
+
def _write_items(self):
# loop over data, column major
A = np.atleast_2d(self.arr).flatten('F')
@@ -893,11 +893,11 @@
# No interesting conversion possible
raise TypeError('Could not convert %s (type %s) to array'
% (arr, type(arr)))
- args = (self.stream,
- narr,
- name,
- is_global,
- self.unicode_strings,
+ args = (self.stream,
+ narr,
+ name,
+ is_global,
+ self.unicode_strings,
self.long_field_names)
if isinstance(narr, MatlabFunction):
return Mat5FunctionWriter(*args)
Modified: trunk/scipy/ndimage/doccer.py
===================================================================
--- trunk/scipy/ndimage/doccer.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/ndimage/doccer.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -94,7 +94,7 @@
unindent_params : {False, True}, boolean, optional
If True, strip common indentation from all parameters in
docdict
-
+
Returns
-------
decfunc : function
Modified: trunk/scipy/ndimage/filters.py
===================================================================
--- trunk/scipy/ndimage/filters.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/ndimage/filters.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -89,7 +89,7 @@
'extra_arguments':_extra_arguments_doc,
'extra_keywords':_extra_keywords_doc,
}
-
+
docfiller = doccer.filldoc(docdict)
@docfiller
@@ -99,7 +99,7 @@
The lines of the array along the given axis are correlated with the
given weights.
-
+
Parameters
----------
%(input)s
@@ -921,7 +921,7 @@
%(cval)s
%(origin)s
%(extra_arguments)s
- %(extra_keywords)s
+ %(extra_keywords)s
"""
if extra_keywords is None:
extra_keywords = {}
@@ -962,7 +962,7 @@
%(cval)s
%(origin)s
%(extra_arguments)s
- %(extra_keywords)s
+ %(extra_keywords)s
"""
if extra_keywords is None:
extra_keywords = {}
Modified: trunk/scipy/ndimage/tests/test_doccer.py
===================================================================
--- trunk/scipy/ndimage/tests/test_doccer.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/ndimage/tests/test_doccer.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -62,8 +62,8 @@
# affect subsequent indent of inserted parameter
yield assert_equal, formatted, """Single line doc Another test
with some indent"""
-
+
def test_decorator():
# with unindentation of parameters
decorator = sndd.filldoc(doc_dict, True)
Modified: trunk/scipy/signal/tests/test_signaltools.py
===================================================================
--- trunk/scipy/signal/tests/test_signaltools.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/signal/tests/test_signaltools.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -38,7 +38,7 @@
[ 3, 33, 53, 67, 1, 78, 74, 55, 12, 83],
[ 7, 11, 46, 70, 60, 47, 24, 43, 61, 26],
[32, 61, 88, 7, 39, 4, 92, 64, 45, 61]]
-
+
d = signal.medfilt(f, [7, 3])
e = signal.medfilt2d(np.array(f, np.float), [7, 3])
assert_array_equal(d, [[ 0, 50, 50, 50, 42, 15, 15, 18, 27, 0],
Modified: trunk/scipy/stats/stats.py
===================================================================
--- trunk/scipy/stats/stats.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/stats/stats.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -1904,7 +1904,7 @@
>>> from scipy import stats
>>> import numpy as np
-
+
>>> #fix seed to get the same result
>>> np.random.seed(7654567)
>>> rvs = stats.norm.rvs(loc=5,scale=10,size=(50,2))
@@ -1938,14 +1938,14 @@
d = np.mean(a,axis) - popmean
v = np.var(a, axis, ddof=1)
-
+
t = d / np.sqrt(v/float(n))
t = np.where((d==0)*(v==0), 1.0, t) #define t=0/0 = 1, identical mean, var
prob = distributions.t.sf(np.abs(t),df)*2 #use np.abs to get upper tail
#distributions.t.sf currently does not propagate nans
#this can be dropped, if distributions.t.sf propagates nans
#if this is removed, then prob = prob[()] needs to be removed
- prob = np.where(np.isnan(t), np.nan, prob)
+ prob = np.where(np.isnan(t), np.nan, prob)
if t.ndim == 0:
t = t[()]
@@ -2004,7 +2004,7 @@
>>> np.random.seed(12345678)
test with sample with identical means
-
+
>>> rvs1 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> rvs2 = stats.norm.rvs(loc=5,scale=10,size=500)
>>> stats.ttest_ind(rvs1,rvs2)
@@ -2012,7 +2012,7 @@
test with sample with different means
-
+
>>> rvs3 = stats.norm.rvs(loc=8,scale=10,size=500)
>>> stats.ttest_ind(rvs1,rvs3)
(-5.0434013458585092, 5.4302979468623391e-007)
@@ -2032,7 +2032,7 @@
t = d/np.sqrt(svar*(1.0/n1 + 1.0/n2))
t = np.where((d==0)*(svar==0), 1.0, t) #define t=0/0 = 0, identical means
prob = distributions.t.sf(np.abs(t),df)*2#use np.abs to get upper tail
-
+
#distributions.t.sf currently does not propagate nans
#this can be dropped, if distributions.t.sf propagates nans
#if this is removed, then prob = prob[()] needs to be removed
@@ -2041,7 +2041,7 @@
if t.ndim == 0:
t = t[()]
prob = prob[()]
-
+
return t, prob
@@ -2113,15 +2113,15 @@
d = (a-b).astype('d')
v = np.var(d,axis,ddof=1)
dm = np.mean(d, axis)
-
+
t = dm / np.sqrt(v/float(n))
- t = np.where((dm==0)*(v==0), 1.0, t) #define t=0/0 = 1, zero mean and var
+ t = np.where((dm==0)*(v==0), 1.0, t) #define t=0/0 = 1, zero mean and var
prob = distributions.t.sf(np.abs(t),df)*2 #use np.abs to get upper tail
#distributions.t.sf currently does not propagate nans
#this can be dropped, if distributions.t.sf propagates nans
#if this is removed, then prob = prob[()] needs to be removed
prob = np.where(np.isnan(t), np.nan, prob)
-
+
## if not np.isscalar(t):
## probs = np.reshape(probs, t.shape) # this should be redundant
## if not np.isscalar(prob) and len(prob) == 1:
Modified: trunk/scipy/stats/tests/test_stats.py
===================================================================
--- trunk/scipy/stats/tests/test_stats.py 2008-12-31 07:02:20 UTC (rev 5306)
+++ trunk/scipy/stats/tests/test_stats.py 2008-12-31 07:13:05 UTC (rev 5307)
@@ -1088,18 +1088,18 @@
t,p = stats.ttest_rel([0,0,0],[1,1,1])
assert_equal((np.abs(t),p), (np.inf, 0))
assert_equal(stats.ttest_rel([0,0,0], [0,0,0]), (1.0, 0.42264973081037427))
-
+
#check that nan in input array result in nan output
anan = np.array([[1,np.nan],[-1,1]])
assert_equal(stats.ttest_ind(anan, np.zeros((2,2))),([0, np.nan], [1,np.nan]))
-
-
+
+
def test_ttest_ind():
#regression test
tr = 1.0912746897927283
pr = 0.27647818616351882
tpr = ([tr,-tr],[pr,pr])
-
+
rvs2 = np.linspace(1,100,100)
rvs1 = np.linspace(5,105,100)
rvs1_2D = np.array([rvs1, rvs2])
@@ -1133,15 +1133,15 @@
#check that nan in input array result in nan output
anan = np.array([[1,np.nan],[-1,1]])
assert_equal(stats.ttest_ind(anan, np.zeros((2,2))),([0, np.nan], [1,np.nan]))
-
-
+
+
def test_ttest_1samp_new():
n1, n2, n3 = (10,15,20)
rvn1 = stats.norm.rvs(loc=5,scale=10,size=(n1,n2,n3))
rvn2 = stats.norm.rvs(loc=5,scale=10,size=(n1,n2,n3))
-
+
#check multidimensional array and correct axis handling
#deterministic rvn1 and rvn2 would be better as in test_ttest_rel
t1,p1 = stats.ttest_1samp(rvn1[:,:,:], np.ones((n2,n3)),axis=0)
From scipy-svn at scipy.org Wed Dec 31 02:52:00 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 01:52:00 -0600 (CST)
Subject: [Scipy-svn] r5308 - trunk/doc/release
Message-ID: <20081231075200.1450DC7C00B@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 01:51:58 -0600 (Wed, 31 Dec 2008)
New Revision: 5308
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
added details about improved documentation
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-31 07:13:05 UTC (rev 5307)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-31 07:51:58 UTC (rev 5308)
@@ -184,11 +184,17 @@
Major documentation improvements
--------------------------------
-Scipy documentation is now more accessible than previously; you can
-view a HTML reference manual online at http://docs.scipy.org/ or
-download it as a PDF file. An updated tutorial is also available, and
-it shows how to use several essential parts of Scipy.
+SciPy documentation is greatly improved; you can
+view a HTML reference manual `online `__ or
+download it as a PDF file. The new reference guide was built using
+the popular `Sphinx tool `__.
+This release also includes an updated tutorial, which hadn't been
+available since SciPy was ported to NumPy in 2005. While not
+comprehensive, the tutorial shows how to use several essential
+parts of Scipy. It also includes the ``ndimage`` documentation
+from the ``numarray`` manual.
+
Nevertheless, more effort is still needed on the documentation front.
Luckily, contributing to Scipy documentation is now easier than
before: if you find that a part of it requires improvements, and want
From scipy-svn at scipy.org Wed Dec 31 06:13:40 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 05:13:40 -0600 (CST)
Subject: [Scipy-svn] r5309 - trunk/scipy/io/matlab
Message-ID: <20081231111340.AFD8AC7C015@scipy.org>
Author: matthew.brett at gmail.com
Date: 2008-12-31 05:13:37 -0600 (Wed, 31 Dec 2008)
New Revision: 5309
Modified:
trunk/scipy/io/matlab/gzipstreams.py
Log:
Fixed brain error in calculation of zip stream length
Modified: trunk/scipy/io/matlab/gzipstreams.py
===================================================================
--- trunk/scipy/io/matlab/gzipstreams.py 2008-12-31 07:51:58 UTC (rev 5308)
+++ trunk/scipy/io/matlab/gzipstreams.py 2008-12-31 11:13:37 UTC (rev 5309)
@@ -53,30 +53,21 @@
'A hand'
>>> ZF.tell()
6
- >>> F = StringIO(compress(S))
- >>> ZF = GzipInputStream(F, 6) # with length
- >>> ZF.read()
- 'A hand'
- >>> ZF.read()
- ''
- >>> ZF.tell()
- 6
- >>>
'''
blocksize = 16384 # 16K
- def __init__(self, fileobj, length=None):
+ def __init__(self, fileobj, zipped_length=None):
''' Initialize GzipInputStream
Parameters
----------
fileobj : file-like object
Object only need implement ``read`` method
- length : None or int, optional
- Uncompressed length of input stream in bytes
+ zipped_length : None or int, optional
+ Compressed length of input stream in bytes
'''
self.fileobj = fileobj
- self.length=length
+ self.zipped_length=zipped_length
self.exhausted = False
self.unzipped_pos = 0
self.data = ""
@@ -95,24 +86,21 @@
read_to_end = bytes == -1
n_to_fetch = self.blocksize
while read_to_end or len(self.data) < bytes:
- if self.length: # do not read beyond specified length
- n_to_fetch = min(self.length-self._bytes_read,
+ if self.zipped_length: # do not read beyond specified length
+ n_to_fetch = min(self.zipped_length-self._bytes_read,
self.blocksize)
if n_to_fetch == 0:
self.exhausted = True
break
data = self.fileobj.read(n_to_fetch)
+ self._bytes_read += len(data)
if data:
- self.__add_data(self._unzipper.decompress(data))
+ self.data += self._unzipper.decompress(data)
if len(data) < n_to_fetch: # hit end of file
- self.__add_data(self._unzipper.flush())
+ self.data += self._unzipper.flush()
self.exhausted = True
break
- def __add_data(self, data):
- self.data += data
- self._bytes_read += len(data)
-
def seek(self, offset, whence=0):
''' Set position in uncompressed stream
@@ -157,7 +145,7 @@
If *bytes* is a positive integer, read this many bytes
from file. If *bytes* == -1 (the default), read all bytes
to the end of file, where the end of the file is detected
- by running out of read data, or by the ``length``
+ by running out of read data, or by the ``zipped_length``
attribute.
Returns
From scipy-svn at scipy.org Wed Dec 31 15:37:17 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 14:37:17 -0600 (CST)
Subject: [Scipy-svn] r5310 - trunk/scipy/ndimage/tests
Message-ID: <20081231203717.606B8C7C015@scipy.org>
Author: alan.mcintyre
Date: 2008-12-31 14:36:21 -0600 (Wed, 31 Dec 2008)
New Revision: 5310
Modified:
trunk/scipy/ndimage/tests/test_regression.py
Log:
Use run_module_suite instead of deprecated NumpyTest.
Modified: trunk/scipy/ndimage/tests/test_regression.py
===================================================================
--- trunk/scipy/ndimage/tests/test_regression.py 2008-12-31 11:13:37 UTC (rev 5309)
+++ trunk/scipy/ndimage/tests/test_regression.py 2008-12-31 20:36:21 UTC (rev 5310)
@@ -17,4 +17,4 @@
ndimage.zoom(x, 2, output=np.zeros((6,8)))
if __name__ == "__main__":
- NumpyTest().run()
+ run_module_suite()
From scipy-svn at scipy.org Wed Dec 31 17:06:02 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 16:06:02 -0600 (CST)
Subject: [Scipy-svn] r5311 - trunk/doc/release
Message-ID: <20081231220602.4EA95C8410C@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 16:06:00 -0600 (Wed, 31 Dec 2008)
New Revision: 5311
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
add blurb about deprecated io functions
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-31 20:36:21 UTC (rev 5310)
+++ trunk/doc/release/0.7.0-notes.rst 2008-12-31 22:06:00 UTC (rev 5311)
@@ -75,7 +75,14 @@
NumPy 1.1.0 and will take place over many release. SciPy 0.7.0 has several
changes including:
-* many of the functions in scipy.io have been deprecated
+* Several functions in ``scipy.io`` have been deprecated and will be removed
+ in the 0.8.0 release including ``npfile``, ``save``, ``load``, ``create_module``,
+ ``create_shelf``, ``objload``, ``objsave``, ``fopen``, ``read_array``,
+ ``write_array``, ``fread``, ``fwrite``, ``bswap``, ``packbits``, ``unpackbits``,
+ and ``convert_objectarray``. Some of these functions have been replaced by
+ NumPy's raw reading and writing capabilities, memory-mapping capabilities,
+ or array methods. Others have been moved from SciPy to NumPy, since basic
+ array reading and writing capability is now handled by NumPy.
* the Matlab (TM) file readers/writers have a number of improvements:
* default version 5
From scipy-svn at scipy.org Wed Dec 31 17:16:37 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 16:16:37 -0600 (CST)
Subject: [Scipy-svn] r5312 - in trunk/scipy: io/matlab stats/tests
Message-ID: <20081231221637.E35D0C8410C@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 16:16:36 -0600 (Wed, 31 Dec 2008)
New Revision: 5312
Modified:
trunk/scipy/io/matlab/mio5.py
trunk/scipy/stats/tests/test_discrete_basic.py
Log:
identity test faster than equality test
Modified: trunk/scipy/io/matlab/mio5.py
===================================================================
--- trunk/scipy/io/matlab/mio5.py 2008-12-31 22:06:00 UTC (rev 5311)
+++ trunk/scipy/io/matlab/mio5.py 2008-12-31 22:16:36 UTC (rev 5312)
@@ -904,7 +904,7 @@
if isinstance(narr, MatlabObject):
return Mat5ObjectWriter(*args)
if narr.dtype.hasobject: # cell or struct array
- if narr.dtype.fields == None:
+ if narr.dtype.fields is None:
return Mat5CellWriter(*args)
else:
return Mat5StructWriter(*args)
Modified: trunk/scipy/stats/tests/test_discrete_basic.py
===================================================================
--- trunk/scipy/stats/tests/test_discrete_basic.py 2008-12-31 22:06:00 UTC (rev 5311)
+++ trunk/scipy/stats/tests/test_discrete_basic.py 2008-12-31 22:16:36 UTC (rev 5312)
@@ -28,7 +28,7 @@
def test_discrete_basic():
for distname, arg in distdiscrete:
distfn = getattr(stats,distname)
- #assert stats.dlaplace.rvs(0.8) != None
+ #assert stats.dlaplace.rvs(0.8) is not None
np.random.seed(9765456)
rvs = distfn.rvs(size=2000,*arg)
m,v = distfn.stats(*arg)
From scipy-svn at scipy.org Wed Dec 31 17:22:46 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 16:22:46 -0600 (CST)
Subject: [Scipy-svn] r5313 - in trunk/scipy: io io/matlab
sparse/linalg/dsolve/umfpack/tests
Message-ID: <20081231222246.E6DA3C8410C@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 16:22:45 -0600 (Wed, 31 Dec 2008)
New Revision: 5313
Modified:
trunk/scipy/io/matlab/mio.py
trunk/scipy/io/mmio.py
trunk/scipy/sparse/linalg/dsolve/umfpack/tests/try_umfpack.py
Log:
use string method over slicing
Modified: trunk/scipy/io/matlab/mio.py
===================================================================
--- trunk/scipy/io/matlab/mio.py 2008-12-31 22:16:36 UTC (rev 5312)
+++ trunk/scipy/io/matlab/mio.py 2008-12-31 22:22:45 UTC (rev 5313)
@@ -25,7 +25,7 @@
warnings.warn('Searching for mat files on python system path will be ' +
'removed in future versions of scipy',
FutureWarning, stacklevel=2)
- if appendmat and file_name[-4:] == ".mat":
+ if appendmat and file_name.endswith(".mat"):
file_name = file_name[:-4]
if os.sep in file_name:
full_name = file_name
Modified: trunk/scipy/io/mmio.py
===================================================================
--- trunk/scipy/io/mmio.py 2008-12-31 22:16:36 UTC (rev 5312)
+++ trunk/scipy/io/mmio.py 2008-12-31 22:22:45 UTC (rev 5313)
@@ -208,10 +208,10 @@
elif os.path.isfile(filespec+'.mtx.bz2'):
filespec = filespec + '.mtx.bz2'
# open filename
- if filespec[-3:] == '.gz':
+ if filespec.endswith('.gz'):
import gzip
stream = gzip.open(filespec, mode)
- elif filespec[-4:] == '.bz2':
+ elif filespec.endswith('.bz2'):
import bz2
stream = bz2.BZ2File(filespec, 'r')
else:
Modified: trunk/scipy/sparse/linalg/dsolve/umfpack/tests/try_umfpack.py
===================================================================
--- trunk/scipy/sparse/linalg/dsolve/umfpack/tests/try_umfpack.py 2008-12-31 22:16:36 UTC (rev 5312)
+++ trunk/scipy/sparse/linalg/dsolve/umfpack/tests/try_umfpack.py 2008-12-31 22:22:45 UTC (rev 5313)
@@ -88,7 +88,7 @@
print 'format:', options.format
print 'reading...'
- if fileName[-3:] == '.gz':
+ if fileName.endswith('.gz'):
fd = gzip.open( fileName )
else:
fd = open( fileName )
From scipy-svn at scipy.org Wed Dec 31 19:32:12 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 18:32:12 -0600 (CST)
Subject: [Scipy-svn] r5314 - trunk/doc/release
Message-ID: <20090101003212.B9941C8410D@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 18:32:11 -0600 (Wed, 31 Dec 2008)
New Revision: 5314
Modified:
trunk/doc/release/0.7.0-notes.rst
Log:
introduction to release notes
Modified: trunk/doc/release/0.7.0-notes.rst
===================================================================
--- trunk/doc/release/0.7.0-notes.rst 2008-12-31 22:22:45 UTC (rev 5313)
+++ trunk/doc/release/0.7.0-notes.rst 2009-01-01 00:32:11 UTC (rev 5314)
@@ -4,10 +4,24 @@
.. contents::
-This stable release comes almost one year after the 0.6.0 release
+This new minor release comes almost one year after the 0.6.0 release
and contains many new features, numerous bug-fixes, improved test
-coverage, and better documentation.
+coverage, and better documentation. There have been a number of
+deprecations and API changes in this release, which are documented
+below. While NumPy is an extremely stable, production-ready package,
+SciPy is still under rapid development. Every effort is made to ensure
+that our code is as stable and bug-free as possible (e.g., this release
+almost doubles the number of unit tests compared to 0.6.0). However, as
+we work toward the first stable, production-ready release (1.0.0), we
+will be adding new modules and packages and we reserve the right to modify
+SciPy's API and move code around to make the overall code organization
+as intuitive as possible for new users.
+All users are encouraged to upgrade to this release as there are a large
+number of bug-fixes and optimizations. Moreover, our development attention
+will now shift to bug-fix releases on the 0.7.x branch and new feature on
+the development trunk.
+
Please note that unlike previous versions of SciPy, this release
requires Python 2.4 or 2.5. This release also requires NumPy 1.2.0
or greater.
From scipy-svn at scipy.org Wed Dec 31 20:12:36 2008
From: scipy-svn at scipy.org (scipy-svn at scipy.org)
Date: Wed, 31 Dec 2008 19:12:36 -0600 (CST)
Subject: [Scipy-svn] r5315 - trunk
Message-ID: <20090101011236.C4592C8410D@scipy.org>
Author: jarrod.millman
Date: 2008-12-31 19:12:34 -0600 (Wed, 31 Dec 2008)
New Revision: 5315
Removed:
trunk/new_manifest.sh
Modified:
trunk/MANIFEST.in
Log:
updating MANIFEST.in
Modified: trunk/MANIFEST.in
===================================================================
--- trunk/MANIFEST.in 2009-01-01 00:32:11 UTC (rev 5314)
+++ trunk/MANIFEST.in 2009-01-01 01:12:34 UTC (rev 5315)
@@ -1,8 +1,20 @@
-# This automatically generated by new_manifest.sh
+# Use .add_data_files and .add_data_dir methods in a appropriate
+# setup.py files to include non-python files such as documentation,
+# data, etc files to distribution. Avoid using MANIFEST.in for that.
#
-# Note: for files required to build extensions, you probably want to
-# place them in the Extension depend list, rather than in this file.
-#
+include MANIFEST.in
+include *.txt
+include setupscons.py
+include setupegg.py
include setup.py
-include *.txt
include scipy/*.py
+## Adding scons build relateed files not found by distutils
+#recursive-include numpy/core/code_generators *.py
+#include numpy/core/include/numpy/numpyconfig.h.in
+#recursive-include numpy SConstruct
+# Add documentation: we don't use add_data_dir since we do not want to include
+# this at installation, only for sdist-generated tarballs
+include doc/Makefile doc/postprocess.py
+recursive-include doc/release *
+recursive-include doc/source *
+recursive-include doc/sphinxext *
Deleted: trunk/new_manifest.sh
===================================================================
--- trunk/new_manifest.sh 2009-01-01 00:32:11 UTC (rev 5314)
+++ trunk/new_manifest.sh 2009-01-01 01:12:34 UTC (rev 5315)
@@ -1,19 +0,0 @@
-#!/bin/sh
-
-# This little script re-generates MANIFEST.in to include files that
-# wouldn't otherwise get picked up by distutils. This is relevant when
-# building source distributions using "python setup.py sdist", which
-# would otherwise leave these files out.
-
-MANIFEST_IN=MANIFEST.in
-
-cat < $MANIFEST_IN
-# This automatically generated by new_manifest.sh
-#
-# Note: for files required to build extensions, you probably want to
-# place them in the Extension depend list, rather than in this file.
-#
-include setup.py
-include *.txt
-include scipy/*.py
-EOF