From 1a14c0e21fd664a215b3744478ca2885923fb011 Mon Sep 17 00:00:00 2001
From: thoo <theinhtay@gmail.com>
Date: Mon, 14 Jan 2019 15:06:19 -0500
Subject: [PATCH 1/5] Fix flake8-rst errors

---
 doc/source/enhancingperf.rst | 102 ++++++++++++++++++-----------------
 setup.cfg                    |   1 -
 2 files changed, 53 insertions(+), 50 deletions(-)

diff --git a/doc/source/enhancingperf.rst b/doc/source/enhancingperf.rst
index a4a96eea4d8e2..e9052b44dac99 100644
--- a/doc/source/enhancingperf.rst
+++ b/doc/source/enhancingperf.rst
@@ -73,7 +73,7 @@ four calls) using the `prun ipython magic function <http://ipython.org/ipython-d
 
 .. ipython:: python
 
-   %prun -l 4 df.apply(lambda x: integrate_f(x['a'], x['b'], x['N']), axis=1)
+   %prun -l 4 df.apply(lambda x: integrate_f(x['a'], x['b'], x['N']), axis=1)  # noqa E999
 
 By far the majority of time is spend inside either ``integrate_f`` or ``f``,
 hence we'll concentrate our efforts cythonizing these two functions.
@@ -189,8 +189,10 @@ in Python, so maybe we could minimize these by cythonizing the apply part.
       ...:     for i in range(N):
       ...:         s += f_typed(a + i * dx)
       ...:     return s * dx
-      ...: cpdef np.ndarray[double] apply_integrate_f(np.ndarray col_a, np.ndarray col_b, np.ndarray col_N):
-      ...:     assert (col_a.dtype == np.float and col_b.dtype == np.float and col_N.dtype == np.int)
+      ...: cpdef np.ndarray[double] apply_integrate_f(np.ndarray col_a, np.ndarray col_b,
+      ...:                                            np.ndarray col_N):
+      ...:     assert (col_a.dtype == np.float
+      ...:             and col_b.dtype == np.float and col_N.dtype == np.int)
       ...:     cdef Py_ssize_t i, n = len(col_N)
       ...:     assert (len(col_a) == len(col_b) == n)
       ...:     cdef np.ndarray[double] res = np.empty(n)
@@ -271,7 +273,9 @@ advanced Cython techniques:
       ...:     return s * dx
       ...: @cython.boundscheck(False)
       ...: @cython.wraparound(False)
-      ...: cpdef np.ndarray[double] apply_integrate_f_wrap(np.ndarray[double] col_a, np.ndarray[double] col_b, np.ndarray[int] col_N):
+      ...: cpdef np.ndarray[double] apply_integrate_f_wrap(np.ndarray[double] col_a,
+      ...:                                                 np.ndarray[double] col_b,
+      ...:                                                 np.ndarray[int] col_N):
       ...:     cdef int i, n = len(col_N)
       ...:     assert len(col_a) == len(col_b) == n
       ...:     cdef np.ndarray[double] res = np.empty(n)
@@ -282,7 +286,7 @@ advanced Cython techniques:
 
 .. code-block:: ipython
 
-   In [4]: %timeit apply_integrate_f_wrap(df['a'].values, df['b'].values, df['N'].values)
+   In [4]: %timeit (apply_integrate_f_wrap(df['a'].values, df['b'].values, df['N'].values)
    1000 loops, best of 3: 987 us per loop
 
 Even faster, with the caveat that a bug in our Cython code (an off-by-one error,
@@ -317,45 +321,45 @@ take the plain Python code from above and annotate with the ``@jit`` decorator.
 
 .. code-block:: python
 
-    import numba
+   import numba
 
 
-    @numba.jit
-    def f_plain(x):
-        return x * (x - 1)
+   @numba.jit
+   def f_plain(x):
+       return x * (x - 1)
 
 
-    @numba.jit
-    def integrate_f_numba(a, b, N):
-        s = 0
-        dx = (b - a) / N
-        for i in range(N):
-            s += f_plain(a + i * dx)
-        return s * dx
+   @numba.jit
+   def integrate_f_numba(a, b, N):
+       s = 0
+       dx = (b - a) / N
+       for i in range(N):
+           s += f_plain(a + i * dx)
+       return s * dx
 
 
-    @numba.jit
-    def apply_integrate_f_numba(col_a, col_b, col_N):
-        n = len(col_N)
-        result = np.empty(n, dtype='float64')
-        assert len(col_a) == len(col_b) == n
-        for i in range(n):
-            result[i] = integrate_f_numba(col_a[i], col_b[i], col_N[i])
-        return result
+   @numba.jit
+   def apply_integrate_f_numba(col_a, col_b, col_N):
+       n = len(col_N)
+       result = np.empty(n, dtype='float64')
+       assert len(col_a) == len(col_b) == n
+       for i in range(n):
+           result[i] = integrate_f_numba(col_a[i], col_b[i], col_N[i])
+       return result
 
 
-    def compute_numba(df):
-        result = apply_integrate_f_numba(df['a'].values, df['b'].values,
-                                         df['N'].values)
-        return pd.Series(result, index=df.index, name='result')
+   def compute_numba(df):
+       result = apply_integrate_f_numba(df['a'].values, df['b'].values,
+                                        df['N'].values)
+       return pd.Series(result, index=df.index, name='result')
 
 Note that we directly pass NumPy arrays to the Numba function. ``compute_numba`` is just a wrapper that provides a
 nicer interface by passing/returning pandas objects.
 
 .. code-block:: ipython
 
-    In [4]: %timeit compute_numba(df)
-    1000 loops, best of 3: 798 us per loop
+   In [4]: %timeit compute_numba(df)
+   1000 loops, best of 3: 798 us per loop
 
 In this example, using Numba was faster than Cython.
 
@@ -368,30 +372,30 @@ Consider the following toy example of doubling each observation:
 
 .. code-block:: python
 
-    import numba
+   import numba
 
 
-    def double_every_value_nonumba(x):
-        return x * 2
+   def double_every_value_nonumba(x):
+       return x * 2
 
 
-    @numba.vectorize
-    def double_every_value_withnumba(x):
-        return x * 2
+   @numba.vectorize
+   def double_every_value_withnumba(x):  # noqa E501
+       return x * 2
 
 .. code-block:: ipython
 
-    # Custom function without numba
-    In [5]: %timeit df['col1_doubled'] = df.a.apply(double_every_value_nonumba)
-    1000 loops, best of 3: 797 us per loop
+   # Custom function without numba
+   In [5]: %timeit df['col1_doubled'] = df.a.apply(double_every_value_nonumba)  # noqa E501
+   1000 loops, best of 3: 797 us per loop
 
-    # Standard implementation (faster than a custom function)
-    In [6]: %timeit df['col1_doubled'] = df.a*2
-    1000 loops, best of 3: 233 us per loop
+   # Standard implementation (faster than a custom function)
+   In [6]: %timeit df['col1_doubled'] = df.a * 2
+   1000 loops, best of 3: 233 us per loop
 
-    # Custom function with numba
-    In [7]: %timeit df['col1_doubled'] = double_every_value_withnumba(df.a.values)
-    1000 loops, best of 3: 145 us per loop
+   # Custom function with numba
+   In [7]: %timeit (df['col1_doubled'] = double_every_value_with_numba(df.a.values)
+   1000 loops, best of 3: 145 us per loop
 
 Caveats
 ~~~~~~~
@@ -545,11 +549,11 @@ Now let's do the same thing but with comparisons:
 
    Operations such as
 
-      .. code-block:: python
+     .. code-block:: python
 
-         1 and 2  # would parse to 1 & 2, but should evaluate to 2
-         3 or 4  # would parse to 3 | 4, but should evaluate to 3
-         ~1  # this is okay, but slower when using eval
+        1 and 2  # would parse to 1 & 2, but should evaluate to 2
+        3 or 4  # would parse to 3 | 4, but should evaluate to 3
+        ~1  # this is okay, but slower when using eval
 
    should be performed in Python. An exception will be raised if you try to
    perform any boolean/bitwise operations with scalar operands that are not
diff --git a/setup.cfg b/setup.cfg
index 44d92c0b8777f..95c71826a80d4 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -48,7 +48,6 @@ ignore = E402,  # module level import not at top of file
 exclude =
     doc/source/basics.rst
     doc/source/contributing_docstring.rst
-    doc/source/enhancingperf.rst
 
 
 [yapf]

From f0a1306d61e25a34af346054cc1b449966dc9801 Mon Sep 17 00:00:00 2001
From: thoo <theinhtay@gmail.com>
Date: Mon, 14 Jan 2019 15:09:30 -0500
Subject: [PATCH 2/5] remove ()

---
 doc/source/enhancingperf.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/enhancingperf.rst b/doc/source/enhancingperf.rst
index e9052b44dac99..5a6d525b5d10f 100644
--- a/doc/source/enhancingperf.rst
+++ b/doc/source/enhancingperf.rst
@@ -286,7 +286,7 @@ advanced Cython techniques:
 
 .. code-block:: ipython
 
-   In [4]: %timeit (apply_integrate_f_wrap(df['a'].values, df['b'].values, df['N'].values)
+   In [4]: %timeit apply_integrate_f_wrap(df['a'].values, df['b'].values, df['N'].values
    1000 loops, best of 3: 987 us per loop
 
 Even faster, with the caveat that a bug in our Cython code (an off-by-one error,

From 3119562324f92f5ecf95e17b76bdd4a4a265f19c Mon Sep 17 00:00:00 2001
From: thoo <theinhtay@gmail.com>
Date: Mon, 14 Jan 2019 15:10:41 -0500
Subject: [PATCH 3/5] add )

---
 doc/source/enhancingperf.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/enhancingperf.rst b/doc/source/enhancingperf.rst
index 5a6d525b5d10f..f4fcdedd8acec 100644
--- a/doc/source/enhancingperf.rst
+++ b/doc/source/enhancingperf.rst
@@ -286,7 +286,7 @@ advanced Cython techniques:
 
 .. code-block:: ipython
 
-   In [4]: %timeit apply_integrate_f_wrap(df['a'].values, df['b'].values, df['N'].values
+   In [4]: %timeit apply_integrate_f_wrap(df['a'].values, df['b'].values, df['N'].values)
    1000 loops, best of 3: 987 us per loop
 
 Even faster, with the caveat that a bug in our Cython code (an off-by-one error,

From 37b96f0bbed3a678bc1af9269307ef80abdb26e4 Mon Sep 17 00:00:00 2001
From: thoo <theinhtay@gmail.com>
Date: Mon, 14 Jan 2019 15:14:12 -0500
Subject: [PATCH 4/5] undone unnecessary spaces

---
 doc/source/enhancingperf.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/source/enhancingperf.rst b/doc/source/enhancingperf.rst
index f4fcdedd8acec..da2db3e4f1f75 100644
--- a/doc/source/enhancingperf.rst
+++ b/doc/source/enhancingperf.rst
@@ -549,11 +549,11 @@ Now let's do the same thing but with comparisons:
 
    Operations such as
 
-     .. code-block:: python
+      .. code-block:: python
 
-        1 and 2  # would parse to 1 & 2, but should evaluate to 2
-        3 or 4  # would parse to 3 | 4, but should evaluate to 3
-        ~1  # this is okay, but slower when using eval
+         1 and 2  # would parse to 1 & 2, but should evaluate to 2
+         3 or 4  # would parse to 3 | 4, but should evaluate to 3
+         ~1  # this is okay, but slower when using eval
 
    should be performed in Python. An exception will be raised if you try to
    perform any boolean/bitwise operations with scalar operands that are not

From d01ac2bcbf06e25ba21c127b2e55671fbb8fedfc Mon Sep 17 00:00:00 2001
From: thoo <theinhtay@gmail.com>
Date: Mon, 14 Jan 2019 15:15:41 -0500
Subject: [PATCH 5/5] fix with_numba

---
 doc/source/enhancingperf.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/enhancingperf.rst b/doc/source/enhancingperf.rst
index da2db3e4f1f75..0e3d389aa4f6e 100644
--- a/doc/source/enhancingperf.rst
+++ b/doc/source/enhancingperf.rst
@@ -394,7 +394,7 @@ Consider the following toy example of doubling each observation:
    1000 loops, best of 3: 233 us per loop
 
    # Custom function with numba
-   In [7]: %timeit (df['col1_doubled'] = double_every_value_with_numba(df.a.values)
+   In [7]: %timeit (df['col1_doubled'] = double_every_value_withnumba(df.a.values)
    1000 loops, best of 3: 145 us per loop
 
 Caveats