updated tutorials

punctuation, minor stylistic issues

Author: mkg33

doc/API.rst.txt

@@ -83,7 +83,7 @@ section that the submodule in question is public.
 API definition
 --------------
 
-Every submodule listed below is public.  That means that these submodules are
+Every submodule listed below is public. That means that these submodules are
 unlikely to be renamed or changed in an incompatible way, and if that is
 necessary, a deprecation warning will be raised for one SciPy release before the
 change is made.
@@ -159,8 +159,8 @@ following, a *SciPy module* is defined as a Python package, say
 
 * Ideally, each SciPy module should be as self-contained as possible.
   That is, it should have minimal dependencies on other packages or
-  modules.  Even dependencies on other SciPy modules should be kept to
-  a minimum.  A dependency on NumPy is of course assumed.
+  modules. Even dependencies on other SciPy modules should be kept to
+  a minimum. A dependency on NumPy is of course assumed.
 
 * Directory ``yyy/`` contains:
 
@@ -187,7 +187,7 @@ following, a *SciPy module* is defined as a Python package, say
   module.
 
   Tutorial-style documentation with extensive examples should be
-  separate, and put under ``doc/source/tutorial/``
+  separate and put under ``doc/source/tutorial/``.
 
 See the existing SciPy submodules for guidance.
 

doc/source/tutorial/fft.rst

@@ -9,28 +9,28 @@ Fourier Transforms (:mod:`scipy.fft`)
 
 
 Fourier analysis is a method for expressing a function as a sum of periodic
-components, and for recovering the signal from those components.  When both
+components, and for recovering the signal from those components. When both
 the function and its Fourier transform are replaced with discretized
-counterparts, it is called the discrete Fourier transform (DFT).  The DFT has
+counterparts, it is called the discrete Fourier transform (DFT). The DFT has
 become a mainstay of numerical computing in part because of a very fast
 algorithm for computing it, called the Fast Fourier Transform (FFT), which was
 known to Gauss (1805) and was brought to light in its current form by Cooley
-and Tukey [CT65]_.  Press et al. [NR07]_ provide an accessible introduction to
+and Tukey [CT65]_. Press et al. [NR07]_ provide an accessible introduction to
 Fourier analysis and its applications.
 
 .. note::
 
    PyFFTW_ provides a way to replace a number of functions in `scipy.fft`
    with its own functions, which are usually significantly faster, via
-   pyfftw.interfaces_.  Because PyFFTW_ relies on the GPL-licensed FFTW_ it
-   cannot be included in SciPy.  Users for whom the speed of FFT routines is
+   pyfftw.interfaces_. Because PyFFTW_ relies on the GPL-licensed FFTW_ it
+   cannot be included in SciPy. Users for whom the speed of FFT routines is
    critical should consider installing PyFFTW_.
 
 
 Fast Fourier transforms
 -----------------------
 
-One dimensional discrete Fourier transforms
+1-D discrete Fourier transforms
 ___________________________________________
 
 The FFT `y[k]` of length :math:`N` of the length-:math:`N` sequence `x[n]` is
@@ -47,7 +47,7 @@ and the inverse transform is defined as follows
     x[n] = \frac{1}{N} \sum_{k=0}^{N-1} e^{2 \pi j \frac{k n}{N} } y[k] \, .
 
 These transforms can be calculated by means of :func:`fft` and :func:`ifft`,
-respectively as shown in the following example.
+respectively, as shown in the following example.
 
 >>> from scipy.fft import fft, ifft
 >>> x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])
@@ -76,8 +76,8 @@ which corresponds to :math:`y[0]`. For N even, the elements
 :math:`y[1]...y[N/2-1]` contain the positive-frequency terms, and the elements
 :math:`y[N/2]...y[N-1]` contain the negative-frequency terms, in order of
 decreasingly negative frequency. For N odd, the elements
-:math:`y[1]...y[(N-1)/2]` contain the positive- frequency terms, and the
-elements :math:`y[(N+1)/2]...y[N-1]` contain the negative- frequency terms, in
+:math:`y[1]...y[(N-1)/2]` contain the positive-frequency terms, and the
+elements :math:`y[(N+1)/2]...y[N-1]` contain the negative-frequency terms, in
 order of decreasingly negative frequency.
 
 In case the sequence x is real-valued, the values of :math:`y[n]` for positive
@@ -104,7 +104,7 @@ The example plots the FFT of the sum of two sines.
     >>> plt.show()
 
 
-The FFT input signal is inherently truncated. This truncation can be modelled
+The FFT input signal is inherently truncated. This truncation can be modeled
 as multiplication of an infinite signal with a rectangular window function. In
 the spectral domain this multiplication becomes convolution of the signal
 spectrum with the window function spectrum, being of form :math:`\sin(x)/x`.
@@ -181,7 +181,7 @@ The function :func:`rfft` calculates the FFT of a real sequence and outputs the
 complex FFT coefficients :math:`y[n]` for only half of the frequency range. The
 remaining negative frequency components are implied by the Hermitian symmetry of
 the FFT for a real input (``y[n] = conj(y[-n])``). In case of N being even:
-:math:`[Re(y[0]) + 0j, y[1], ..., Re(y[N/2]) + 0j]`; in case N being odd
+:math:`[Re(y[0]) + 0j, y[1], ..., Re(y[N/2]) + 0j]`; in case of N being odd
 :math:`[Re(y[0]) + 0j, y[1], ..., y[N/2]`. The terms shown explicitly as
 :math:`Re(y[k]) + 0j` are restricted to be purely real since, by the hermitian
 property, they are their own complex conjugate.
@@ -210,34 +210,34 @@ array([ 4.5       +0.j        ,  2.08155948-1.65109876j,
 array([ 4.5       +0.j        ,  2.08155948-1.65109876j,
         -1.83155948+1.60822041j])
 
-Notice that the :func:`rfft` of odd and even length signals are the same shape.
-By default, :func:`irfft` assumes the ouput signal should be of even length. And
-so for odd signals, will give the wrong result:
+Notice that the :func:`rfft` of odd and even length signals are of the same shape.
+By default, :func:`irfft` assumes the output signal should be of even length. And
+so, for odd signals, it will give the wrong result:
 
 >>> irfft(yr)
 array([ 1.70788987,  2.40843925, -0.37366961,  0.75734049])
 
-To recover the original odd length signal, we **must** pass the output shape by
+To recover the original odd-length signal, we **must** pass the output shape by
 the `n` parameter.
 
 >>> irfft(yr, n=len(x))
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
 
 
-Two and n-dimensional discrete Fourier transforms
+2- and N-D discrete Fourier transforms
 _________________________________________________
 
-The functions :func:`fft2` and :func:`ifft2` provide 2-dimensional FFT, and
-IFFT, respectively. Similar, :func:`fftn` and :func:`ifftn` provide
-n-dimensional FFT, and IFFT, respectively.
+The functions :func:`fft2` and :func:`ifft2` provide 2-D FFT and
+IFFT, respectively. Similarly, :func:`fftn` and :func:`ifftn` provide
+N-D FFT, and IFFT, respectively.
 
-For real input signals, similar to :func:`rfft`, we have the functions
-:func:`rfft2` and :func:`irfft2` for 2-dimensional real transforms;
-:func:`rfftn` and :func:`irfftn` for n-dimensional real transforms.
+For real-input signals, similarly to :func:`rfft`, we have the functions
+:func:`rfft2` and :func:`irfft2` for 2-D real transforms;
+:func:`rfftn` and :func:`irfftn` for N-D real transforms.
 
-The example below demonstrates a 2-dimensional IFFT and plots the resulting
-(2-dimensional) time-domain signals.
+The example below demonstrates a 2-D IFFT and plots the resulting
+(2-D) time-domain signals.
 
 .. plot::
 
@@ -294,7 +294,7 @@ SciPy uses the following definition of the unnormalized DCT-I
     \cos\left(\frac{\pi nk}{N-1}\right),
     \qquad 0 \le k < N.
 
-Note that the DCT-I is only supported for input size > 1
+Note that the DCT-I is only supported for input size > 1.
 
 Type II DCT
 ___________
@@ -320,7 +320,7 @@ In this case, the DCT "base functions" :math:`\phi_k[n] = 2 f \cos
 
 .. math::
 
-   \sum_{n=0}^{N-1} \phi_k[n] \phi_l[n] = \delta_{lk}
+   \sum_{n=0}^{N-1} \phi_k[n] \phi_l[n] = \delta_{lk}.
 
 
 Type III DCT
@@ -347,23 +347,23 @@ ____________
 
 
 The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up to a
-factor `2N`. The orthonormalized DCT-III is exactly the inverse of the
+factor of `2N`. The orthonormalized DCT-III is exactly the inverse of the
 orthonormalized DCT- II. The function :func:`idct` performs the mappings between
-the DCT and IDCT types, as well as performing the correct normalization.
+the DCT and IDCT types, as well as the correct normalization.
 
 The following example shows the relation between DCT and IDCT for different
 types and normalizations.
 
 >>> from scipy.fft import dct, idct
 >>> x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])
 
-The DCT-II and DCT-III are each others inverses, so for an orthonormal transform
+The DCT-II and DCT-III are each other's inverses, so for an orthonormal transform
 we return back to the original signal.
 
 >>> dct(dct(x, type=2, norm='ortho'), type=3, norm='ortho')
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
-Doing the same under default normalization however, we pick up an extra scaling
+Doing the same under default normalization, however, we pick up an extra scaling
 factor of :math:`2N=10` since the forward transform is unnormalized.
 
 >>> dct(dct(x, type=2), type=3)
@@ -376,8 +376,8 @@ giving a correctly normalized result.
 >>> idct(dct(x, type=2), type=2)
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
-Analogous results can be seen for the DCT-I which is its own inverse up to a
-factor of :math:`2(N-1)`
+Analogous results can be seen for the DCT-I, which is its own inverse up to a
+factor of :math:`2(N-1)`.
 
 >>> dct(dct(x, type=1, norm='ortho'), type=1, norm='ortho')
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
@@ -388,7 +388,7 @@ array([ 8. ,  16.,  8. , -8. ,  12.])
 >>> idct(dct(x, type=1), type=1)
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
-And for the DCT-IV which is also its own inverse up to a factor of :math:`2N`
+And for the DCT-IV, which is also its own inverse up to a factor of :math:`2N`.
 
 >>> dct(dct(x, type=4, norm='ortho'), type=4, norm='ortho')
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
@@ -408,7 +408,7 @@ Zeroing out the other coefficients leads to a small reconstruction error, a
 fact which is exploited in lossy signal compression (e.g. JPEG compression).
 
 The example below shows a signal x and two reconstructions (:math:`x_{20}` and
-:math:`x_{15}`)from the signal's DCT coefficients. The signal :math:`x_{20}`
+:math:`x_{15}`) from the signal's DCT coefficients. The signal :math:`x_{20}`
 is reconstructed from the first 20 DCT coefficients, :math:`x_{15}` is
 reconstructed from the first 15 DCT coefficients. It can be seen that the
 relative error of using 20 coefficients is still very small (~0.1%), but
@@ -446,7 +446,7 @@ Discrete Sine Transforms
 SciPy provides a DST [Mak]_ with the function :func:`dst` and a corresponding IDST
 with the function :func:`idst`.
 
-There are theoretically 8 types of the DST for different combinations of
+There are, theoretically, 8 types of the DST for different combinations of
 even/odd boundary conditions and boundary off sets [WPS]_, only the first 3
 types are implemented in scipy.
 
@@ -462,7 +462,7 @@ definition of the unnormalized DST-I (``norm=None``):
     \right), \qquad 0 \le k < N.
 
 Note also that the DST-I is only supported for input size > 1. The
-(unnormalized) DST-I is its own inverse, up to a factor `2(N+1)`.
+(unnormalized) DST-I is its own inverse, up to a factor of `2(N+1)`.
 
 Type II DST
 ___________
@@ -491,19 +491,19 @@ DST and IDST
 ____________
 
 
-The following example below shows the relation between DST and IDST for
+The following example shows the relation between DST and IDST for
 different types and normalizations.
 
 >>> from scipy.fft import dst, idst
 >>> x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])
 
-The DST-II and DST-III are each others inverses, so for an orthonormal transform
+The DST-II and DST-III are each other's inverses, so for an orthonormal transform
 we return back to the original signal.
 
 >>> dst(dst(x, type=2, norm='ortho'), type=3, norm='ortho')
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
-Doing the same under default normalization however, we pick up an extra scaling
+Doing the same under default normalization, however, we pick up an extra scaling
 factor of :math:`2N=10` since the forward transform is unnormalized.
 
 >>> dst(dst(x, type=2), type=3)
@@ -515,8 +515,8 @@ giving a correctly normalized result.
 >>> idst(dst(x, type=2), type=2)
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
-Analogous results can be seen for the DST-I which is its own inverse up to a
-factor of :math:`2(N-1)`
+Analogous results can be seen for the DST-I, which is its own inverse up to a
+factor of :math:`2(N-1)`.
 
 >>> dst(dst(x, type=1, norm='ortho'), type=1, norm='ortho')
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
@@ -527,7 +527,7 @@ array([ 12.,  24.,  12., -12.,  18.])
 >>> idst(dst(x, type=1), type=1)
 array([ 1. ,  2. ,  1. , -1. ,  1.5])
 
-And for the DST-IV which is also its own inverse up to a factor of :math:`2N`
+And for the DST-IV, which is also its own inverse up to a factor of :math:`2N`.
 
 >>> dst(dst(x, type=4, norm='ortho'), type=4, norm='ortho')
 array([ 1. ,  2. ,  1. , -1. ,  1.5])