Merge pull request #63 from davidbradway/NumPy

numpy -> NumPy

Author: rougier

01-preface.rst

@@ -19,11 +19,11 @@ Diseases`_, the Bordeaux laboratory for research in computer science
 (LaBRI_), the `University of Bordeaux`_ and the national center for scientific
 research (CNRS_).
 
-He has been using Python for more than 15 years and numpy for more than 10
+He has been using Python for more than 15 years and NumPy for more than 10
 years for modeling in neuroscience, machine learning and for advanced
 visualization (OpenGL). Nicolas P. Rougier is the author of several online
-resources and tutorials (Matplotlib, numpy, OpenGL) and he's teaching Python,
-numpy and scientific visualization at the University of Bordeaux and in various
+resources and tutorials (Matplotlib, NumPy, OpenGL) and he's teaching Python,
+NumPy and scientific visualization at the University of Bordeaux and in various
 conferences and schools worldwide (SciPy, EuroScipy, etc). He's also the author
 of the popular article `Ten Simple Rules for Better Figures`_ and a popular
 `matplotlib tutorial
@@ -55,15 +55,15 @@ Prerequisites
 +++++++++++++
 
 This is not a Python beginner guide and you should have an intermediate level in
-Python and ideally a beginner level in numpy. If this is not the case, have
+Python and ideally a beginner level in NumPy. If this is not the case, have
 a look at the bibliography_ for a curated list of resources.
 
 
 Conventions
 +++++++++++
 
 We will use usual naming conventions. If not stated explicitly, each script
-should import numpy, scipy and matplotlib as:
+should import NumPy, scipy and matplotlib as:
 
 .. code-block:: python
    
@@ -80,7 +80,7 @@ Packages    Version
 =========== =========
 Python      3.6.0
 ----------- ---------
-Numpy       1.12.0
+NumPy       1.12.0
 ----------- ---------
 Scipy       0.18.1
 ----------- ---------

02-introduction.rst

@@ -15,7 +15,7 @@ Simple example
    such a case, you might want to use the magic command `%timeit` instead of the
    `custom one <code/tools.py>`_ I wrote.
 
-Numpy is all about vectorization. If you are familiar with Python, this is the
+NumPy is all about vectorization. If you are familiar with Python, this is the
 main difficulty you'll face because you'll need to change your way of thinking
 and your new friends (among others) are named "vectors", "arrays", "views" or
 "ufuncs".
@@ -114,19 +114,19 @@ things faster:
    10 loops, best of 3: 2.21 msec per loop
 
 We gained 85% of computation-time compared to the previous version, not so
-bad. But the advantage of this new version is that it makes numpy vectorization
-super simple. We just have to translate itertools call into numpy ones.
+bad. But the advantage of this new version is that it makes NumPy vectorization
+super simple. We just have to translate itertools call into NumPy ones.
 
 .. code:: python
        
    def random_walk_fastest(n=1000):
-       # No 's' in numpy choice (Python offers choice & choices)
+       # No 's' in NumPy choice (Python offers choice & choices)
        steps = np.random.choice([-1,+1], n)
        return np.cumsum(steps)
 
    walk = random_walk_fastest(1000)
            
-Not too difficult, but we gained a factor 500x using numpy:
+Not too difficult, but we gained a factor 500x using NumPy:
 
 .. code:: pycon
 
@@ -143,7 +143,7 @@ Readability vs speed
 --------------------
 
 Before heading to the next chapter, I would like to warn you about a potential
-problem you may encounter once you'll have become familiar with numpy. It is a
+problem you may encounter once you'll have become familiar with NumPy. It is a
 very powerful library and you can make wonders with it but, most of the time,
 this comes at the price of readability. If you don't comment your code at the
 time of writing, you won't be able to tell what a function is doing after a few
@@ -166,5 +166,5 @@ and you don't need to read this book).
        return candidates[mask]
 
 As you may have guessed, the second function is the
-vectorized-optimized-faster-numpy version of the first function. It is 10 times
+vectorized-optimized-faster-NumPy version of the first function. It is 10 times
 faster than the pure Python version, but it is hardly readable.

03-anatomy.rst

@@ -8,16 +8,16 @@ Anatomy of an array
 Introduction
 ------------
 
-As explained in the Preface_, you should have a basic experience with numpy to
+As explained in the Preface_, you should have a basic experience with NumPy to
 read this book. If this is not the case, you'd better start with a beginner
 tutorial before coming back here. Consequently I'll only give here a quick
-reminder on the basic anatomy of numpy arrays, especially regarding the memory
+reminder on the basic anatomy of NumPy arrays, especially regarding the memory
 layout, view, copy and the data type. They are critical notions to
-understand if you want your computation to benefit from numpy philosophy.
+understand if you want your computation to benefit from NumPy philosophy.
 
 Let's consider a simple example where we want to clear all the values from an
 array which has the dtype `np.float32`. How does one write it to maximize speed? The
-below syntax is rather obvious (at least for those familiar with numpy) but the
+below syntax is rather obvious (at least for those familiar with NumPy) but the
 above question asks to find the fastest operation.
 
 .. code-block:: python
@@ -53,15 +53,15 @@ Interestingly enough, the obvious way of clearing all the values is not the
 fastest. By casting the array into a larger data type such as `np.float64`, we
 gained a 25% speed factor. But, by viewing the array as a byte array
 (`np.int8`), we gained a 50% factor. The reason for such speedup are to be
-found in the internal numpy machinery and the compiler optimization. This
-simple example illustrates the philosophy of numpy as we'll see in the next
+found in the internal NumPy machinery and the compiler optimization. This
+simple example illustrates the philosophy of NumPy as we'll see in the next
 section below.
 
 
 Memory layout
 -------------
 
-The `numpy documentation
+The `NumPy documentation
 <https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html>`_ defines the
 ndarray class very clearly:
 
@@ -333,7 +333,7 @@ copy:
    >>> print(Z2.base is None)
    True
 
-Note that some numpy functions return a view when possible (e.g. `ravel
+Note that some NumPy functions return a view when possible (e.g. `ravel
 <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ravel.html>`_)
 while some others always return a copy (e.g. `flatten
 <https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flatten.html#numpy.ndarray.flatten>`_):

04-code-vectorization.rst

@@ -10,7 +10,7 @@ Introduction
 ------------
 
 Code vectorization means that the problem you're trying to solve is inherently
-vectorizable and only requires a few numpy tricks to make it faster. Of course
+vectorizable and only requires a few NumPy tricks to make it faster. Of course
 it does not mean it is easy or straightforward, but at least it does not
 necessitate totally rethinking your problem (as it will be the case in the
 `Problem vectorization`_ chapter). Still, it may require some experience to see
@@ -23,7 +23,7 @@ is:
    def add_python(Z1,Z2):
        return [z1+z2 for (z1,z2) in zip(Z1,Z2)]
 
-This first naive solution can be vectorized very easily using numpy:
+This first naive solution can be vectorized very easily using NumPy:
 
 .. code-block:: python
 
@@ -195,7 +195,7 @@ discovered by Richard K. Guy in 1970.
    :width: 100%
 
 
-Numpy implementation
+NumPy implementation
 ++++++++++++++++++++
 
 Starting from the Python version, the vectorization of the Game of Life
@@ -230,7 +230,7 @@ sure to consider all the eight neighbours.
                     Z[1:-1, :-2]                + Z[1:-1,2:] +
                     Z[2:  , :-2] + Z[2:  ,1:-1] + Z[2:  ,2:])
 
-For the rule enforcement, we can write a first version using numpy's
+For the rule enforcement, we can write a first version using NumPy's
 `argwhere
 <http://docs.scipy.org/doc/numpy/reference/generated/numpy.argwhere.html>`_
 method that will give us the indices where a given condition is True.
@@ -259,7 +259,7 @@ method that will give us the indices where a given condition is True.
 Even if this first version does not use nested loops, it is far from optimal
 because of the use of the four `argwhere` calls that may be quite slow. We can
 instead factorize the rules into cells that will survive (stay at 1) and cells
-that will give birth. For doing this, we can take advantage of Numpy boolean
+that will give birth. For doing this, we can take advantage of NumPy boolean
 capability and write quite naturally:
 
 .. note::
@@ -442,17 +442,17 @@ actually computes the sequence :math:`f_c(f_c(f_c ...)))`. The vectorization of
 such code is not totally straightforward because the internal `return` implies a
 differential processing of the element. Once it has diverged, we don't need to
 iterate any more and we can safely return the iteration count at
-divergence. The problem is to then do the same in numpy. But how?
+divergence. The problem is to then do the same in NumPy. But how?
 
-Numpy implementation
+NumPy implementation
 ++++++++++++++++++++
 
 The trick is to search at each iteration values that have not yet
 diverged and update relevant information for these values and only
 these values. Because we start from :math:`Z = 0`, we know that each
 value will be updated at least once (when they're equal to :math:`0`,
 they have not yet diverged) and will stop being updated as soon as
-they've diverged. To do that, we'll use numpy fancy indexing with the
+they've diverged. To do that, we'll use NumPy fancy indexing with the
 `less(x1,x2)` function that return the truth value of `(x1 < x2)`
 element-wise.
 
@@ -484,14 +484,14 @@ Here is the benchmark:
    1 loops, best of 3: 1.15 sec per loop
 
 
-Faster numpy implementation
+Faster NumPy implementation
 +++++++++++++++++++++++++++
 
 The gain is roughly a 5x factor, not as much as we could have
 expected. Part of the problem is that the `np.less` function implies
 :math:`xn \times yn` tests at every iteration while we know that some
 values have already diverged. Even if these tests are performed at the
-C level (through numpy), the cost is nonetheless
+C level (through NumPy), the cost is nonetheless
 significant. Another approach proposed by `Dan Goodman
 <https://thesamovar.wordpress.com/>`_ is to work on a dynamic array at
 each iteration that stores only the points which have not yet
@@ -574,7 +574,7 @@ We now want to measure the fractal dimension of the Mandelbrot set using the
 <https://en.wikipedia.org/wiki/Minkowski–Bouligand_dimension>`_. To do that, we
 need to do box-counting with a decreasing box size (see figure below). As you
 can imagine, we cannot use pure Python because it would be way too slow. The goal of
-the exercise is to write a function using numpy that takes a two-dimensional
+the exercise is to write a function using NumPy that takes a two-dimensional
 float array and returns the dimension. We'll consider values in the array to be
 normalized (i.e. all values are between 0 and 1).
 
@@ -602,7 +602,7 @@ References
 
 * `How To Quickly Compute the Mandelbrot Set in Python <https://www.ibm.com/developerworks/community/blogs/jfp/entry/How_To_Compute_Mandelbrodt_Set_Quickly?lang=en>`_, Jean Francois Puget, 2015.
 * `My Christmas Gift: Mandelbrot Set Computation In Python <https://www.ibm.com/developerworks/community/blogs/jfp/entry/My_Christmas_Gift?lang=en>`_, Jean Francois Puget, 2015.
-* `Fast fractals with Python and Numpy <https://thesamovar.wordpress.com/2009/03/22/fast-fractals-with-python-and-numpy/>`_, Dan Goodman, 2009.
+* `Fast fractals with Python and NumPy <https://thesamovar.wordpress.com/2009/03/22/fast-fractals-with-python-and-numpy/>`_, Dan Goodman, 2009.
 * `Renormalizing the Mandelbrot Escape <http://linas.org/art-gallery/escape/escape.html>`_, Linas Vepstas, 1997.
 
 
@@ -724,7 +724,7 @@ To complete the picture, we can also create a `Flock` object:
 
 Using this approach, we can have up to 50 boids until the computation
 time becomes too slow for a smooth animation. As you may have guessed,
-we can do much better using numpy, but let me first point out the main
+we can do much better using NumPy, but let me first point out the main
 problem with this Python implementation. If you look at the code, you
 will certainly notice there is a lot of redundancy. More precisely, we
 do not exploit the fact that the Euclidean distance is reflexive, that
@@ -736,10 +736,10 @@ caching the result for the other functions. In the end, we are
 computing :math:`3n^2` distances instead of :math:`\frac{n^2}{2}`.
 
 
-Numpy implementation
+NumPy implementation
 ++++++++++++++++++++
 
-As you might expect, the numpy implementation takes a different approach and
+As you might expect, the NumPy implementation takes a different approach and
 we'll gather all our boids into a `position` array and a `velocity` array:
 
 .. code:: python

05-problem-vectorization.rst

@@ -44,7 +44,7 @@ know it will be slow:
 
 How to vectorize the problem then? If you remember your linear algebra course,
 you may have identified the expression `X[i] * Y[j]` to be very similar to a
-matrix product expression. So maybe we could benefit from some numpy
+matrix product expression. So maybe we could benefit from some NumPy
 speedup. One wrong solution would be to write:
 
 .. code:: python
@@ -54,7 +54,7 @@ speedup. One wrong solution would be to write:
 
 This is wrong because the `X*Y` expression will actually compute a new vector
 `Z` such that `Z[i] = X[i] * Y[i]` and this is not what we want. Instead, we
-can exploit numpy broadcasting by first reshaping the two vectors and then
+can exploit NumPy broadcasting by first reshaping the two vectors and then
 multiply them:
 
 .. code:: python
@@ -145,15 +145,15 @@ factor of 70,000 with problem vectorization, just by writing our problem
 differently (even though you cannot expect such a huge speedup in all
 situations). However, code vectorization remains an important factor, and if we
 rewrite the last solution the Python way, the improvement is good but not as much as
-in the numpy version:
+in the NumPy version:
 
 .. code:: python
 
    def compute_python_better(x, y):
        return sum(x)*sum(y)
 
 This new Python version is much faster than the previous Python version, but
-still, it is 50 times slower than the numpy version:
+still, it is 50 times slower than the NumPy version:
 
 .. code:: python
 
@@ -371,7 +371,7 @@ cell's new value is computed as the maximum value between the current cell value
 and the discounted (`gamma=0.9` in the case below) 4 neighbour values. The
 process starts as soon as the starting node value becomes strictly positive.
 
-The numpy implementation is straightforward if we take advantage of the
+The NumPy implementation is straightforward if we take advantage of the
 `generic_filter` (from `scipy.ndimage`) for the diffusion process:
 
 .. code:: python
@@ -497,12 +497,12 @@ two methods into a hybrid method.
 
 However, the biggest problem for particle-based simulation is that particle
 interaction requires finding neighbouring particles and this has a cost as
-we've seen in the boids case. If we target Python and numpy only, it is probably
+we've seen in the boids case. If we target Python and NumPy only, it is probably
 better to choose the Eulerian method since vectorization will be almost trivial
 compared to the Lagrangian method.
 
 
-Numpy implementation
+NumPy implementation
 ++++++++++++++++++++
 
 I won't explain all the theory behind computational fluid dynamics because
@@ -518,7 +518,7 @@ wrote a very nice article for SIGGRAPH 1999 describing a technique to have
 stable fluids over time (i.e. whose solution in the long term does not
 diverge). `Alberto Santini <https://github.com/albertosantini/python-fluid>`_
 wrote a Python replication a long time ago (using numarray!) such that I only
-had to adapt it to modern numpy and accelerate it a bit using modern numpy
+had to adapt it to modern NumPy and accelerate it a bit using modern NumPy
 tricks.
 
 I won't comment the code since it would be too long, but you can read the