Typo

Author: rougier

05-problem-vectorization.rst

@@ -104,8 +104,9 @@ compute it only once:
            result += X[i]*Ysum
        return result
 
-Not so bad, we have the inner loop, meaning with transform a :math:`O(n^2)` complexity
-into :math:`O(n)` complexity. Using the same approach, we can now write:
+Not so bad, we have removed the inner loop, meaning with transform a
+:math:`O(n^2)` complexity into :math:`O(n)` complexity. Using the same
+approach, we can now write:
 
 .. code:: python
 
@@ -137,7 +138,7 @@ It is shorter, clearer and much, much faster:
 We have indeed reformulated our problem, taking advantage of the fact that
 :math:`\sum_{ij}{X_i}{Y_j} = \sum_{i}X_i \sum_{j}Y_j$` and we've learned in the
 meantime that there are two kinds of vectorization: code vectorization and
-the problem vectorization. The latter is the most difficult but the most
+problem vectorization. The latter is the most difficult but the most
 important because this is where you can expect huge gains in speed. In this
 simple example, we gain a factor of 150 with code vectorization but we gained a
 factor of 70,000 with problem vectorization, just by writing our problem

book.html

@@ -1429,8 +1429,9 @@ <h2><a class="toc-backref" href="#id15">Introduction</a></h2>
         <span class="name">result</span> <span class="operator">+=</span> <span class="name">X</span><span class="punctuation">[</span><span class="name">i</span><span class="punctuation">]</span><span class="operator">*</span><span class="name">Ysum</span>
     <span class="keyword">return</span> <span class="name">result</span>
 </pre>
-<p>Not so bad, we have the inner loop, meaning with transform a <span class="formula"><i>O</i>(<i>n</i><sup>2</sup>)</span> complexity
-into <span class="formula"><i>O</i>(<i>n</i>)</span> complexity. Using the same approach, we can now write:</p>
+<p>Not so bad, we have removed the inner loop, meaning with transform a
+<span class="formula"><i>O</i>(<i>n</i><sup>2</sup>)</span> complexity into <span class="formula"><i>O</i>(<i>n</i>)</span> complexity. Using the same
+approach, we can now write:</p>
 <pre class="code python literal-block">
 <span class="keyword">def</span> <span class="name function">compute_numpy_better_3</span><span class="punctuation">(</span><span class="name">x</span><span class="punctuation">,</span> <span class="name">y</span><span class="punctuation">):</span>
     <span class="name">Ysum</span> <span class="operator">=</span> <span class="operator">=</span> <span class="literal number integer">0</span>
@@ -1456,7 +1457,7 @@ <h2><a class="toc-backref" href="#id15">Introduction</a></h2>
 <p>We have indeed reformulated our problem, taking advantage of the fact that
 <span class="formula"><span class="limits"><span class="limit"><span class="symbol">∑</span></span></span><sub><i>ij</i></sub><i>X</i><sub><i>i</i></sub><i>Y</i><sub><i>j</i></sub> = <span class="limits"><span class="limit"><span class="symbol">∑</span></span></span><sub><i>i</i></sub><i>X</i><sub><i>i</i></sub><span class="limits"><span class="limit"><span class="symbol">∑</span></span></span><sub><i>j</i></sub><i>Y</i><sub><i>j</i></sub></span> and we've learned in the
 meantime that there are two kinds of vectorization: code vectorization and
-the problem vectorization. The latter is the most difficult but the most
+problem vectorization. The latter is the most difficult but the most
 important because this is where you can expect huge gains in speed. In this
 simple example, we gain a factor of 150 with code vectorization but we gained a
 factor of 70,000 with problem vectorization, just by writing our problem