Cleanups: Broadcasting, np.hypot, np.pi, etc.

Also fixes a bug in fill_between with masked data.  In the modified test
figures, the area in green is supposed to correspond to the part of the
hatched area where the curve is below y=2.  The new behavior is the
correct one.

Also fixes cbook._reshape2D for scalar object inputs.  Before the fix,
`plt.hist(None)` would fail with `x must have 2 or fewer dimensions`,
which it does have.  Now it fails with a bit later with `unsupported
operands type(s) for +: 'NoneType' and 'float'`, which is hopefully
clearer.

Author: anntzer

doc/api/axis_api.rst

@@ -109,8 +109,8 @@ Ticks, tick labels and Offset text
    Axis.axis_date
 
 
-Data and view internvals
-------------------------
+Data and view intervals
+-----------------------
 
 .. autosummary::
    :toctree: _as_gen

examples/animation/unchained.py

@@ -25,7 +25,7 @@
 # Generate random data
 data = np.random.uniform(0, 1, (64, 75))
 X = np.linspace(-1, 1, data.shape[-1])
-G = 1.5 * np.exp(-4 * X * X)
+G = 1.5 * np.exp(-4 * X ** 2)
 
 # Generate line plots
 lines = []

examples/api/custom_projection_example.py

@@ -434,15 +434,11 @@ def __init__(self, resolution):
             self._resolution = resolution
 
         def transform_non_affine(self, xy):
-            x = xy[:, 0:1]
-            y = xy[:, 1:2]
-
-            quarter_x = 0.25 * x
-            half_y = 0.5 * y
-            z = np.sqrt(1.0 - quarter_x*quarter_x - half_y*half_y)
-            longitude = 2 * np.arctan((z*x) / (2.0 * (2.0*z*z - 1.0)))
+            x, y = xy.T
+            z = np.sqrt(1 - (x / 4) ** 2 - (y / 2) ** 2)
+            longitude = 2 * np.arctan((z * x) / (2 * (2 * z ** 2 - 1)))
             latitude = np.arcsin(y*z)
-            return np.concatenate((longitude, latitude), 1)
+            return np.column_stack([longitude, latitude])
         transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__
 
         def inverted(self):

examples/api/scatter_piecharts.py

@@ -7,7 +7,7 @@
 
 Thanks to Manuel Metz for the example
 """
-import math
+
 import numpy as np
 import matplotlib.pyplot as plt
 
@@ -16,35 +16,33 @@
 r2 = r1 + 0.4  # 40%
 
 # define some sizes of the scatter marker
-sizes = [60, 80, 120]
+sizes = np.array([60, 80, 120])
 
 # calculate the points of the first pie marker
 #
 # these are just the origin (0,0) +
 # some points on a circle cos,sin
-x = [0] + np.cos(np.linspace(0, 2*math.pi*r1, 10)).tolist()
-y = [0] + np.sin(np.linspace(0, 2*math.pi*r1, 10)).tolist()
-
+x = [0] + np.cos(np.linspace(0, 2 * np.pi * r1, 10)).tolist()
+y = [0] + np.sin(np.linspace(0, 2 * np.pi * r1, 10)).tolist()
 xy1 = list(zip(x, y))
-s1 = max(max(x), max(y))
+s1 = np.max(xy1)
 
-# ...
-x = [0] + np.cos(np.linspace(2*math.pi*r1, 2*math.pi*r2, 10)).tolist()
-y = [0] + np.sin(np.linspace(2*math.pi*r1, 2*math.pi*r2, 10)).tolist()
+x = [0] + np.cos(np.linspace(2 * np.pi * r1, 2 * np.pi * r2, 10)).tolist()
+y = [0] + np.sin(np.linspace(2 * np.pi * r1, 2 * np.pi * r2, 10)).tolist()
 xy2 = list(zip(x, y))
-s2 = max(max(x), max(y))
+s2 = np.max(xy2)
 
-x = [0] + np.cos(np.linspace(2*math.pi*r2, 2*math.pi, 10)).tolist()
-y = [0] + np.sin(np.linspace(2*math.pi*r2, 2*math.pi, 10)).tolist()
+x = [0] + np.cos(np.linspace(2 * np.pi * r2, 2 * np.pi, 10)).tolist()
+y = [0] + np.sin(np.linspace(2 * np.pi * r2, 2 * np.pi, 10)).tolist()
 xy3 = list(zip(x, y))
-s3 = max(max(x), max(y))
+s3 = np.max(xy3)
 
 fig, ax = plt.subplots()
-ax.scatter(np.arange(3), np.arange(3), marker=(xy1, 0),
-           s=[s1*s1*_ for _ in sizes], facecolor='blue')
-ax.scatter(np.arange(3), np.arange(3), marker=(xy2, 0),
-           s=[s2*s2*_ for _ in sizes], facecolor='green')
-ax.scatter(np.arange(3), np.arange(3), marker=(xy3, 0),
-           s=[s3*s3*_ for _ in sizes], facecolor='red')
+ax.scatter(range(3), range(3), marker=(xy1, 0),
+           s=s1 ** 2 * sizes, facecolor='blue')
+ax.scatter(range(3), range(3), marker=(xy2, 0),
+           s=s2 ** 2 * sizes, facecolor='green')
+ax.scatter(range(3), range(3), marker=(xy3, 0),
+           s=s3 ** 2 * sizes, facecolor='red')
 
 plt.show()

examples/event_handling/timers.py

@@ -18,7 +18,7 @@ def update_title(axes):
 fig, ax = plt.subplots()
 
 x = np.linspace(-3, 3)
-ax.plot(x, x*x)
+ax.plot(x, x ** 2)
 
 # Create a new timer object. Set the interval to 100 milliseconds
 # (1000 is default) and tell the timer what function should be called.

examples/event_handling/trifinder_event_demo.py

@@ -11,16 +11,15 @@
 from matplotlib.tri import Triangulation
 from matplotlib.patches import Polygon
 import numpy as np
-import math
 
 
 def update_polygon(tri):
     if tri == -1:
         points = [0, 0, 0]
     else:
-        points = triangulation.triangles[tri]
-    xs = triangulation.x[points]
-    ys = triangulation.y[points]
+        points = triang.triangles[tri]
+    xs = triang.x[points]
+    ys = triang.y[points]
     polygon.set_xy(list(zip(xs, ys)))
 
 
@@ -39,23 +38,22 @@ def motion_notify(event):
 n_radii = 5
 min_radius = 0.25
 radii = np.linspace(min_radius, 0.95, n_radii)
-angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi / n_angles
+angles[:, 1::2] += np.pi / n_angles
 x = (radii*np.cos(angles)).flatten()
 y = (radii*np.sin(angles)).flatten()
-triangulation = Triangulation(x, y)
-xmid = x[triangulation.triangles].mean(axis=1)
-ymid = y[triangulation.triangles].mean(axis=1)
-mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
-triangulation.set_mask(mask)
+triang = Triangulation(x, y)
+triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
+                         y[triang.triangles].mean(axis=1))
+                < min_radius)
 
 # Use the triangulation's default TriFinder object.
-trifinder = triangulation.get_trifinder()
+trifinder = triang.get_trifinder()
 
 # Setup plot and callbacks.
 plt.subplot(111, aspect='equal')
-plt.triplot(triangulation, 'bo-')
+plt.triplot(triang, 'bo-')
 polygon = Polygon([[0, 0], [0, 0]], facecolor='y')  # dummy data for xs,ys
 update_polygon(-1)
 plt.gca().add_patch(polygon)

examples/images_contours_and_fields/tricontour_demo.py

@@ -8,7 +8,6 @@
 import matplotlib.pyplot as plt
 import matplotlib.tri as tri
 import numpy as np
-import math
 
 ###############################################################################
 # Creating a Triangulation without specifying the triangles results in the
@@ -20,22 +19,21 @@
 min_radius = 0.25
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi / n_angles
+angles[:, 1::2] += np.pi / n_angles
 
 x = (radii * np.cos(angles)).flatten()
 y = (radii * np.sin(angles)).flatten()
-z = (np.cos(radii) * np.cos(angles * 3.0)).flatten()
+z = (np.cos(radii) * np.cos(3 * angles)).flatten()
 
 # Create the Triangulation; no triangles so Delaunay triangulation created.
 triang = tri.Triangulation(x, y)
 
 # Mask off unwanted triangles.
-xmid = x[triang.triangles].mean(axis=1)
-ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
-triang.set_mask(mask)
+triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
+                         y[triang.triangles].mean(axis=1))
+                < min_radius)
 
 ###############################################################################
 # pcolor plot.

examples/images_contours_and_fields/tricontour_smooth_user.py

@@ -10,7 +10,6 @@
 import matplotlib.pyplot as plt
 import matplotlib.cm as cm
 import numpy as np
-import math
 
 
 #-----------------------------------------------------------------------------
@@ -36,9 +35,9 @@ def function_z(x, y):
 min_radius = 0.15
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi / n_angles
+angles[:, 1::2] += np.pi / n_angles
 
 x = (radii * np.cos(angles)).flatten()
 y = (radii * np.sin(angles)).flatten()
@@ -50,10 +49,9 @@ def function_z(x, y):
 triang = tri.Triangulation(x, y)
 
 # Mask off unwanted triangles.
-xmid = x[triang.triangles].mean(axis=1)
-ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
-triang.set_mask(mask)
+triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
+                         y[triang.triangles].mean(axis=1))
+                < min_radius)
 
 #-----------------------------------------------------------------------------
 # Refine data

examples/images_contours_and_fields/trigradient_demo.py

@@ -5,12 +5,11 @@
 
 Demonstrates computation of gradient with matplotlib.tri.CubicTriInterpolator.
 """
-from matplotlib.tri import Triangulation, UniformTriRefiner,\
-    CubicTriInterpolator
+from matplotlib.tri import (
+    Triangulation, UniformTriRefiner, CubicTriInterpolator)
 import matplotlib.pyplot as plt
 import matplotlib.cm as cm
 import numpy as np
-import math
 
 
 #-----------------------------------------------------------------------------
@@ -33,9 +32,9 @@ def dipole_potential(x, y):
 min_radius = 0.2
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2*math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi/n_angles
+angles[:, 1::2] += np.pi / n_angles
 
 x = (radii*np.cos(angles)).flatten()
 y = (radii*np.sin(angles)).flatten()
@@ -46,10 +45,9 @@ def dipole_potential(x, y):
 triang = Triangulation(x, y)
 
 # Mask off unwanted triangles.
-xmid = x[triang.triangles].mean(axis=1)
-ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid*xmid + ymid*ymid < min_radius*min_radius, 1, 0)
-triang.set_mask(mask)
+triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
+                         y[triang.triangles].mean(axis=1))
+                < min_radius)
 
 #-----------------------------------------------------------------------------
 # Refine data - interpolates the electrical potential V

examples/images_contours_and_fields/tripcolor_demo.py

@@ -8,7 +8,6 @@
 import matplotlib.pyplot as plt
 import matplotlib.tri as tri
 import numpy as np
-import math
 
 ###############################################################################
 # Creating a Triangulation without specifying the triangles results in the
@@ -20,22 +19,21 @@
 min_radius = 0.25
 radii = np.linspace(min_radius, 0.95, n_radii)
 
-angles = np.linspace(0, 2 * math.pi, n_angles, endpoint=False)
+angles = np.linspace(0, 2 * np.pi, n_angles, endpoint=False)
 angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
-angles[:, 1::2] += math.pi / n_angles
+angles[:, 1::2] += np.pi / n_angles
 
 x = (radii * np.cos(angles)).flatten()
 y = (radii * np.sin(angles)).flatten()
-z = (np.cos(radii) * np.cos(angles * 3.0)).flatten()
+z = (np.cos(radii) * np.cos(3 * angles)).flatten()
 
 # Create the Triangulation; no triangles so Delaunay triangulation created.
 triang = tri.Triangulation(x, y)
 
 # Mask off unwanted triangles.
-xmid = x[triang.triangles].mean(axis=1)
-ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid * xmid + ymid * ymid < min_radius * min_radius, 1, 0)
-triang.set_mask(mask)
+triang.set_mask(np.hypot(x[triang.triangles].mean(axis=1),
+                         y[triang.triangles].mean(axis=1))
+                < min_radius)
 
 ###############################################################################
 # tripcolor plot.