Proof reading NumPy

Author: jussienko

docs/mooc/numerical-computing/broadcasting.md

@@ -168,7 +168,7 @@ different number of dimensions. Also, if one of the dimensions is 1, the array
 is "copied" in that dimension to match the other array.
 
 Examples of how the dimensions of arrays are matched when broadcasting
-**succesfully**:
+**successfully**:
 
 ~~~
     a: 8 x 3
@@ -197,7 +197,7 @@ Examples of **failed** broadcasting due to mismatch(es) in the dimensions:
     b:     5 x 1 x 3  # mismatch in the third from last dimension
 ~~~
 
-It is very easy to make wrong assumptions intuitively, so instead careful
+It is very easy to make wrong assumptions intuitively, so careful
 consideration is always needed when broadcasting.
 
 

docs/mooc/numerical-computing/creating-and-accessing.md

@@ -17,7 +17,7 @@ number of elements remains the same.
 
 ### From existing data
 
-NumPy arrays can be created in several different ways. The simplest ways is
+NumPy arrays can be created in several different ways. The simplest way is
 to use the **array** constructor and provide the data directly as an
 argument. For example, in order to generate a one-dimensional array containing
 the numbers 1,2,3,4 one can use:
@@ -36,7 +36,7 @@ number (e.g. [1, 2, 3.1, 4]) then the array created would have used floating
 point type for all elements.
 
 The first argument of `array()` is the data for the array. It can be a single
-list (or tuple), or a nested list of uniformly sized lists that mimicks a
+list (or tuple), or a nested list of uniformly sized lists that mimics a
 multi-dimensional array.
 
 The second argument of `array()` is the datatype to be used for the array. It
@@ -208,7 +208,7 @@ Simple assignment creates a new reference to an array, just like for any other
 Python object. Thus, if you modify the array using the new reference, the
 changes are visible also via any old reference to the same array.
 
-To make a true copy of an array, one should use the *copy()* method:
+To make a true copy of an array, one should use the `copy()` method:
 
 ~~~python
 a = np.arange(10)
@@ -222,7 +222,7 @@ modifications to the elements in the view are directly reflected in the
 original array. In fact, no real copy is made and as such any manipulation
 will just change the original array.
 
-Once again, to make a true copy, one should use the *copy()* method:
+Once again, to make a true copy, one should use the `copy()` method:
 
 ~~~python
 a = np.arange(10)

docs/mooc/numerical-computing/file-io.md

@@ -15,9 +15,10 @@ load and store data in a human-readable format.
 Comments and column delimiters are handled automatically, so usually one can
 read any data file in a column layout into a NumPy array.
 
-Assume we the following measurement data in a called `xy-coordinates.dat`. As
-you can see it also contains an invalid data point that is commented out as
-well as one data point with an undefined value (`nan`).
+Assume we have the following measurement data in a file called
+`xy-coordinates.dat`. As you can see it also contains an invalid data
+point that is commented out as well as one data point with an
+undefined value (`nan`). 
 
 ~~~
 # x          y

docs/mooc/numerical-computing/linear-algebra.md

@@ -9,7 +9,7 @@ polynomial functionality.
 
 # Linear algebra
 
-NumPy includes in-built linear algebra routines that can be quite handy. For
+NumPy includes linear algebra routines that can be quite handy. For
 example, NumPy can calculate matrix and vector products efficiently (`dot`,
 `vdot`), solve eigenproblems (`linalg.eig`, `linalg.eigvals`), solve linear
 systems (`linalg.solve`), and do matrix inversion (`linalg.inv`).

docs/mooc/numerical-computing/numexpr.md

@@ -31,7 +31,7 @@ poly = numexpr.evaluate("((.25*x + .75)*x - 1.5)*x - 2")
 
 The expression is enclosed in quotes and will be evaluated using a single
 C-loop. Speed-ups in comparison to NumPy are typically between 0.95 and 4.
-Works best on arrays that do not fit in CPU cache.
+Performance improves normaly most with arrays that do not fit in CPU cache.
 
 Supported operators and functions include e.g.:
 

docs/mooc/numerical-computing/simple-operations.md

@@ -30,7 +30,7 @@ print(a * a)
 
 NumPy provides also a wide range of elementary mathematical functions (sin,
 cos, exp, sqrt, log, ...) that work with arrays (as well as single values). In
-many ways it can be used as a drop-in replacement for the `math` module.
+many ways NumPy can be used as a drop-in replacement for the `math` module.
 
 ~~~python
 import numpy, math

docs/mooc/numerical-computing/temporary-arrays.md

@@ -52,8 +52,7 @@ c = (numpy.sin(a) + numpy.cos(b)) + 2.0 * a - 4.5 * b
 
 Sometimes it is hard to see how many temporary arrays are needed, but if one
 wants to conserve memory (when working with very, very large arrays), it is
-usually a good idea to do apply operations on an existing array one by one
-instead.
+usually a good idea to apply operations on an existing array one by one:
 
 ~~~python
 c = 2.0 * a
@@ -65,7 +64,7 @@ c += np.cos(b)
 ### Broadcasting and temporary arrays
 
 Broadcasting approaches can also lead to unexpected temporary arrays. For
-example, let use consider the calculation of the pairwise distance of **M**
+example, let us consider the calculation of the pairwise distance of **M**
 points in three dimensions.
 
 Input data is a M x 3 array and output is a M x M array containing the

docs/mooc/numerical-computing/vectorised-operations.md

@@ -11,7 +11,7 @@ loops.
 
 For loops in Python are slow. If one needs to apply a mathematical operation
 on multiple (consecutive) elements of an array, it is always better to use a
-vectorised operation if at all possible.
+vectorised operation if possible.
 
 In practice, a vectorised operation means reframing the code in a manner that
 completely avoids a loop and instead uses e.g. slicing to apply the operation