Use np.hypot whereever possible.

anntzer · anntzer · commit c86fbc73f350 · 2018-01-25T14:35:46.000-08:00
Clearer IMO, although perhaps not for the examples?
diff --git a/examples/event_handling/ginput_manual_clabel_sgskip.py b/examples/event_handling/ginput_manual_clabel_sgskip.py
@@ -71,7 +71,7 @@ def tellme(s):
 def f(x, y, pts):
     z = np.zeros_like(x)
     for p in pts:
-        z = z + 1/(np.sqrt((x - p[0])**2 + (y - p[1])**2))
+        z = z + 1 / np.hypot(x - p[0], y - p[1])
     return 1/z
 
 
diff --git a/examples/event_handling/path_editor.py b/examples/event_handling/path_editor.py
@@ -90,7 +90,7 @@ def get_ind_under_point(self, event):
         xy = np.asarray(self.pathpatch.get_path().vertices)
         xyt = self.pathpatch.get_transform().transform(xy)
         xt, yt = xyt[:, 0], xyt[:, 1]
-        d = np.sqrt((xt - event.x)**2 + (yt - event.y)**2)
+        d = np.hypot(xt - event.x, yt - event.y)
         ind = d.argmin()
 
         if d[ind] >= self.epsilon:
diff --git a/examples/event_handling/pick_event_demo.py b/examples/event_handling/pick_event_demo.py
@@ -123,7 +123,7 @@ def line_picker(line, mouseevent):
         xdata = line.get_xdata()
         ydata = line.get_ydata()
         maxd = 0.05
-        d = np.sqrt((xdata - mouseevent.xdata)**2. + (ydata - mouseevent.ydata)**2.)
+        d = np.hypot(xdata - mouseevent.xdata, ydata - mouseevent.ydata)
 
         ind = np.nonzero(np.less_equal(d, maxd))
         if len(ind):
diff --git a/examples/images_contours_and_fields/contourf_demo.py b/examples/images_contours_and_fields/contourf_demo.py
@@ -30,7 +30,7 @@
 Z[:nr // 6, :nc // 6] = np.ma.masked
 
 # mask a circle in the middle:
-interior = np.sqrt((X**2) + (Y**2)) < 0.5
+interior = np.hypot(X, Y) < 0.5
 Z[interior] = np.ma.masked
 
 # We are using automatic selection of contour levels;
diff --git a/examples/images_contours_and_fields/image_nonuniform.py b/examples/images_contours_and_fields/image_nonuniform.py
@@ -23,7 +23,7 @@
 
 y = np.linspace(-4, 4, 9)
 
-z = np.sqrt(x[np.newaxis, :]**2 + y[:, np.newaxis]**2)
+z = np.hypot(x[np.newaxis, :], y[:, np.newaxis])
 
 fig, axs = plt.subplots(nrows=2, ncols=2)
 fig.subplots_adjust(bottom=0.07, hspace=0.3)
diff --git a/examples/images_contours_and_fields/quadmesh_demo.py b/examples/images_contours_and_fields/quadmesh_demo.py
@@ -20,9 +20,9 @@
 X, Y = np.meshgrid(x, y)
 Qx = np.cos(Y) - np.cos(X)
 Qz = np.sin(Y) + np.sin(X)
-Qx = (Qx + 1.1)
-Z = np.sqrt(X**2 + Y**2) / 5
-Z = (Z - Z.min()) / (Z.max() - Z.min())
+Qx = Qx + 1.1
+Z = np.hypot(X, Y) / 5
+Z = (Z - Z.min()) / Z.ptp()
 
 # The color array can include masked values:
 Zm = ma.masked_where(np.abs(Qz) < 0.5 * np.max(Qz), Z)
diff --git a/examples/images_contours_and_fields/tricontour_smooth_delaunay.py b/examples/images_contours_and_fields/tricontour_smooth_delaunay.py
@@ -36,9 +36,9 @@
 def experiment_res(x, y):
     """ An analytic function representing experiment results """
     x = 2. * x
-    r1 = np.sqrt((0.5 - x)**2 + (0.5 - y)**2)
+    r1 = np.hypot(0.5 - x, 0.5 - y)
     theta1 = np.arctan2(0.5 - x, 0.5 - y)
-    r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2)
+    r2 = np.hypot(-x - 0.2, -y - 0.2)
     theta2 = np.arctan2(-x - 0.2, -y - 0.2)
     z = (4 * (np.exp((r1 / 10)**2) - 1) * 30. * np.cos(3 * theta1) +
          (np.exp((r2 / 10)**2) - 1) * 30. * np.cos(5 * theta2) +
diff --git a/examples/images_contours_and_fields/tricontour_smooth_user.py b/examples/images_contours_and_fields/tricontour_smooth_user.py
@@ -17,9 +17,9 @@
 #-----------------------------------------------------------------------------
 def function_z(x, y):
     """ A function of 2 variables """
-    r1 = np.sqrt((0.5 - x)**2 + (0.5 - y)**2)
+    r1 = np.hypot(0.5 - x, 0.5 - y)
     theta1 = np.arctan2(0.5 - x, 0.5 - y)
-    r2 = np.sqrt((-x - 0.2)**2 + (-y - 0.2)**2)
+    r2 = np.hypot(-x - 0.2, -y - 0.2)
     theta2 = np.arctan2(-x - 0.2, -y - 0.2)
     z = -(2 * (np.exp((r1 / 10)**2) - 1) * 30. * np.cos(7. * theta1) +
           (np.exp((r2 / 10)**2) - 1) * 30. * np.cos(11. * theta2) +
diff --git a/examples/images_contours_and_fields/trigradient_demo.py b/examples/images_contours_and_fields/trigradient_demo.py
@@ -61,7 +61,7 @@ def dipole_potential(x, y):
 tci = CubicTriInterpolator(triang, -V)
 # Gradient requested here at the mesh nodes but could be anywhere else:
 (Ex, Ey) = tci.gradient(triang.x, triang.y)
-E_norm = np.sqrt(Ex**2 + Ey**2)
+E_norm = np.hypot(Ex, Ey)
 
 #-----------------------------------------------------------------------------
 # Plot the triangulation, the potential iso-contours and the vector field
diff --git a/examples/lines_bars_and_markers/scatter_star_poly.py b/examples/lines_bars_and_markers/scatter_star_poly.py
@@ -13,7 +13,7 @@
 
 x = np.random.rand(10)
 y = np.random.rand(10)
-z = np.sqrt(x**2 + y**2)
+z = np.hypot(x, y)
 
 plt.subplot(321)
 plt.scatter(x, y, s=80, c=z, marker=">")
diff --git a/examples/mplot3d/mixed_subplots.py b/examples/mplot3d/mixed_subplots.py
@@ -38,7 +38,7 @@ def f(t):
 X = np.arange(-5, 5, 0.25)
 Y = np.arange(-5, 5, 0.25)
 X, Y = np.meshgrid(X, Y)
-R = np.sqrt(X**2 + Y**2)
+R = np.hypot(X, Y)
 Z = np.sin(R)
 
 surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
diff --git a/examples/mplot3d/surface3d.py b/examples/mplot3d/surface3d.py
@@ -24,7 +24,7 @@
 X = np.arange(-5, 5, 0.25)
 Y = np.arange(-5, 5, 0.25)
 X, Y = np.meshgrid(X, Y)
-R = np.sqrt(X**2 + Y**2)
+R = np.sqrt(X, Y)
 Z = np.sin(R)
 
 # Plot the surface.
diff --git a/examples/mplot3d/surface3d_3.py b/examples/mplot3d/surface3d_3.py
@@ -22,7 +22,7 @@
 Y = np.arange(-5, 5, 0.25)
 ylen = len(Y)
 X, Y = np.meshgrid(X, Y)
-R = np.sqrt(X**2 + Y**2)
+R = np.hypot(X, Y)
 Z = np.sin(R)
 
 # Create an empty array of strings with the same shape as the meshgrid, and
diff --git a/examples/mplot3d/trisurf3d_2.py b/examples/mplot3d/trisurf3d_2.py
@@ -69,7 +69,7 @@
 # Mask off unwanted triangles.
 xmid = x[triang.triangles].mean(axis=1)
 ymid = y[triang.triangles].mean(axis=1)
-mask = np.where(xmid**2 + ymid**2 < min_radius**2, 1, 0)
+mask = np.hypot(xmid, ymid) < min_radius
 triang.set_mask(mask)
 
 # Plot the surface.
diff --git a/examples/mplot3d/voxels_torus.py b/examples/mplot3d/voxels_torus.py
@@ -27,7 +27,7 @@ def midpoints(x):
 rc, thetac, zc = midpoints(r), midpoints(theta), midpoints(z)
 
 # define a wobbly torus about [0.7, *, 0]
-sphere = (rc - 0.7)**2 + (zc + 0.2*np.cos(thetac*2))**2 < 0.2**2
+sphere = np.hypot(rc - 0.7, zc + 0.2*np.cos(thetac*2)) < 0.2
 
 # combine the color components
 hsv = np.zeros(sphere.shape + (3,))
diff --git a/examples/mplot3d/wire3d_animation.py b/examples/mplot3d/wire3d_animation.py
@@ -18,7 +18,7 @@ def generate(X, Y, phi):
     '''
     Generates Z data for the points in the X, Y meshgrid and parameter phi.
     '''
-    R = 1 - np.sqrt(X**2 + Y**2)
+    R = 1 - np.hypot(X, Y)
     return np.cos(2 * np.pi * X + phi) * R
 
 
diff --git a/lib/matplotlib/bezier.py b/lib/matplotlib/bezier.py
@@ -291,11 +291,9 @@ def split_path_inout(path, inside, tolerence=0.01, reorder_inout=False):
 
 
 def inside_circle(cx, cy, r):
-    r2 = r ** 2
-
     def _f(xy):
         x, y = xy
-        return (x - cx) ** 2 + (y - cy) ** 2 < r2
+        return np.hypot(x - cx, y - cy) < r
     return _f
 
 
diff --git a/lib/matplotlib/contour.py b/lib/matplotlib/contour.py
@@ -230,11 +230,7 @@ def print_label(self, linecontour, labelwidth):
 
     def too_close(self, x, y, lw):
         "Return *True* if a label is already near this location."
-        for loc in self.labelXYs:
-            d = np.sqrt((x - loc[0]) ** 2 + (y - loc[1]) ** 2)
-            if d < 1.2 * lw:
-                return True
-        return False
+        return any(np.hypot(x - loc[0], y - loc[1]) < 1.2 * lw for loc in self.labelXYs)
 
     def get_label_coords(self, distances, XX, YY, ysize, lw):
         """
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -81,7 +81,7 @@ def segment_hits(cx, cy, x, y, radius):
     """
     # Process single points specially
     if len(x) < 2:
-        res, = np.nonzero((cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2)
+        res, = np.nonzero(np.hypot(cx - x, cy - y) <= radius)
         return res
 
     # We need to lop the last element off a lot.
@@ -93,25 +93,21 @@ def segment_hits(cx, cy, x, y, radius):
     Lnorm_sq = dx ** 2 + dy ** 2  # Possibly want to eliminate Lnorm==0
     u = ((cx - xr) * dx + (cy - yr) * dy) / Lnorm_sq
     candidates = (u >= 0) & (u <= 1)
-    #if any(candidates): print "candidates",xr[candidates]
 
     # Note that there is a little area near one side of each point
     # which will be near neither segment, and another which will
     # be near both, depending on the angle of the lines.  The
     # following radius test eliminates these ambiguities.
-    point_hits = (cx - x) ** 2 + (cy - y) ** 2 <= radius ** 2
-    #if any(point_hits): print "points",xr[candidates]
+    points_hit = np.hypot(cx - x, cy - y) <= radius
     candidates = candidates & ~(point_hits[:-1] | point_hits[1:])
 
     # For those candidates which remain, determine how far they lie away
     # from the line.
     px, py = xr + u * dx, yr + u * dy
-    line_hits = (cx - px) ** 2 + (cy - py) ** 2 <= radius ** 2
-    #if any(line_hits): print "lines",xr[candidates]
+    line_hits = np.hypot(cx - px, cy - py) <= radius
     line_hits = line_hits & candidates
     points, = point_hits.ravel().nonzero()
     lines, = line_hits.ravel().nonzero()
-    #print points,lines
     return np.concatenate((points, lines))
 
 
@@ -484,17 +480,15 @@ def contains(self, mouseevent):
         else:
             pixels = self.figure.dpi / 72. * self.pickradius
 
-        # the math involved in checking for containment (here and inside of
-        # segment_hits) assumes that it is OK to overflow.  In case the
-        # application has set the error flags such that an exception is raised
-        # on overflow, we temporarily set the appropriate error flags here and
-        # set them back when we are finished.
+        # The math involved in checking for containment (here and inside of
+        # segment_hits) assumes that it is OK to overflow, so temporarily set
+        # the error flags accordingly.
         with np.errstate(all='ignore'):
             # Check for collision
             if self._linestyle in ['None', None]:
                 # If no line, return the nearby point(s)
-                d = (xt - mouseevent.x) ** 2 + (yt - mouseevent.y) ** 2
-                ind, = np.nonzero(np.less_equal(d, pixels ** 2))
+                ind, = np.nonzero(
+                    np.hypot(xt - mouseevent.x, yt - mouseevent.y) <= pixels)
             else:
                 # If line, return the nearby segment(s)
                 ind = segment_hits(mouseevent.x, mouseevent.y, xt, yt, pixels)
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -1363,10 +1363,8 @@ def get_path(self):
         xb1, yb1, xb2, yb2 = self.getpoints(x1, y1, x2, y2, k1)
 
         # a point on the segment 20% of the distance from the tip to the base
-        theta = math.atan2(y2 - y1, x2 - x1)
-        r = math.sqrt((y2 - y1) ** 2. + (x2 - x1) ** 2.)
-        xm = x1 + self.frac * r * math.cos(theta)
-        ym = y1 + self.frac * r * math.sin(theta)
+        xm = x1 + self.frac * (x2 - x1)
+        ym = y1 + self.frac * (y2 - y1)
         xc1, yc1, xc2, yc2 = self.getpoints(x1, y1, xm, ym, k1)
         xd1, yd1, xd2, yd2 = self.getpoints(x1, y1, xm, ym, k2)
 
@@ -2950,10 +2948,10 @@ def connect(self, posA, posB):
                 codes.append(Path.LINETO)
             else:
                 dx1, dy1 = x1 - cx, y1 - cy
-                d1 = (dx1 ** 2 + dy1 ** 2) ** .5
+                d1 = np.hypot(dx1, dy1)
                 f1 = self.rad / d1
                 dx2, dy2 = x2 - cx, y2 - cy
-                d2 = (dx2 ** 2 + dy2 ** 2) ** .5
+                d2 = np.hypot(dx2, dy2)
                 f2 = self.rad / d2
                 vertices.extend([(cx + dx1 * f1, cy + dy1 * f1),
                                  (cx, cy),
@@ -3355,7 +3353,7 @@ def transmute(self, path, mutation_size, linewidth):
 
             head_length = self.head_length * mutation_size
             head_width = self.head_width * mutation_size
-            head_dist = math.sqrt(head_length ** 2 + head_width ** 2)
+            head_dist = np.hypot(head_length, head_width)
             cos_t, sin_t = head_length / head_dist, head_width / head_dist
 
             # begin arrow
diff --git a/lib/matplotlib/projections/geo.py b/lib/matplotlib/projections/geo.py
@@ -470,15 +470,12 @@ def transform_non_affine(self, ll):
             diff_long = longitude - clong
             cos_diff_long = np.cos(diff_long)
 
-            inner_k = (1.0 +
-                       np.sin(clat)*sin_lat +
-                       np.cos(clat)*cos_lat*cos_diff_long)
-            # Prevent divide-by-zero problems
-            inner_k = np.where(inner_k == 0.0, 1e-15, inner_k)
-            k = np.sqrt(2.0 / inner_k)
-            x = k*cos_lat*np.sin(diff_long)
-            y = k*(np.cos(clat)*sin_lat -
-                   np.sin(clat)*cos_lat*cos_diff_long)
+            inner_k = np.max(  # Prevent divide-by-zero problems
+                1 + np.sin(clat)*sin_lat + np.cos(clat)*cos_lat*cos_diff_long,
+                1e-15)
+            k = np.sqrt(2 / inner_k)
+            x = k * cos_lat*np.sin(diff_long)
+            y = k * (np.cos(clat)*sin_lat - np.sin(clat)*cos_lat*cos_diff_long)
 
             return np.concatenate((x, y), 1)
         transform_non_affine.__doc__ = Transform.transform_non_affine.__doc__
@@ -502,8 +499,7 @@ def transform_non_affine(self, xy):
             y = xy[:, 1:2]
             clong = self._center_longitude
             clat = self._center_latitude
-            p = np.sqrt(x*x + y*y)
-            p = np.where(p == 0.0, 1e-9, p)
+            p = np.max(np.hypot(x, y), 1e-9)
             c = 2.0 * np.arcsin(0.5 * p)
             sin_c = np.sin(c)
             cos_c = np.cos(c)
diff --git a/lib/matplotlib/streamplot.py b/lib/matplotlib/streamplot.py
@@ -194,7 +194,7 @@ def streamplot(axes, x, y, u, v, density=1, linewidth=None, color=None,
         streamlines.extend(np.hstack([points[:-1], points[1:]]))
 
         # Add arrows half way along each trajectory.
-        s = np.cumsum(np.sqrt(np.diff(tx) ** 2 + np.diff(ty) ** 2))
+        s = np.cumsum(np.hypot(np.diff(tx), np.diff(ty)))
         n = np.searchsorted(s, s[-1] / 2.)
         arrow_tail = (tx[n], ty[n])
         arrow_head = (np.mean(tx[n:n + 2]), np.mean(ty[n:n + 2]))
@@ -420,7 +420,7 @@ def get_integrator(u, v, dmap, minlength, maxlength, integration_direction):
     # speed (path length) will be in axes-coordinates
     u_ax = u / dmap.grid.nx
     v_ax = v / dmap.grid.ny
-    speed = np.ma.sqrt(u_ax ** 2 + v_ax ** 2)
+    speed = np.ma.hypot(u_ax, v_ax)
 
     def forward_time(xi, yi):
         ds_dt = interpgrid(speed, xi, yi)
@@ -543,7 +543,7 @@ def _integrate_rk12(x0, y0, dmap, f, maxlength):
 
         nx, ny = dmap.grid.shape
         # Error is normalized to the axes coordinates
-        error = np.sqrt(((dx2 - dx1) / nx) ** 2 + ((dy2 - dy1) / ny) ** 2)
+        error = np.hypot((dx2 - dx1) / nx, (dy2 - dy1) / ny)
 
         # Only save step if within error tolerance
         if error < maxerror:
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -1183,7 +1183,7 @@ def test_pcolorargs():
     x = np.linspace(-1.5, 1.5, n)
     y = np.linspace(-1.5, 1.5, n*2)
     X, Y = np.meshgrid(x, y)
-    Z = np.sqrt(X**2 + Y**2)/5
+    Z = np.hypot(X, Y) / 5
 
     _, ax = plt.subplots()
     with pytest.raises(TypeError):
diff --git a/lib/matplotlib/tests/test_contour.py b/lib/matplotlib/tests/test_contour.py
@@ -360,7 +360,7 @@ def test_circular_contour_warning():
     # Check that almost circular contours don't throw a warning
     with pytest.warns(None) as record:
         x, y = np.meshgrid(np.linspace(-2, 2, 4), np.linspace(-2, 2, 4))
-        r = np.sqrt(x ** 2 + y ** 2)
+        r = np.hypot(x, y)
 
         plt.figure()
         cs = plt.contour(x, y, r)
diff --git a/lib/matplotlib/tests/test_image.py b/lib/matplotlib/tests/test_image.py
@@ -760,12 +760,11 @@ def test_mask_image():
 def test_imshow_endianess():
     x = np.arange(10)
     X, Y = np.meshgrid(x, x)
-    Z = ((X-5)**2 + (Y-5)**2)**0.5
+    Z = np.hypot(X - 5, Y - 5)
 
     fig, (ax1, ax2) = plt.subplots(1, 2)
 
-    kwargs = dict(origin="lower", interpolation='nearest',
-                  cmap='viridis')
+    kwargs = dict(origin="lower", interpolation='nearest', cmap='viridis')
 
     ax1.imshow(Z.astype('<f8'), **kwargs)
     ax2.imshow(Z.astype('>f8'), **kwargs)
diff --git a/lib/matplotlib/tests/test_triangulation.py b/lib/matplotlib/tests/test_triangulation.py
diff --git a/lib/matplotlib/tri/tritools.py b/lib/matplotlib/tri/tritools.py
diff --git a/lib/matplotlib/widgets.py b/lib/matplotlib/widgets.py
diff --git a/lib/mpl_toolkits/mplot3d/proj3d.py b/lib/mpl_toolkits/mplot3d/proj3d.py
diff --git a/lib/mpl_toolkits/tests/test_mplot3d.py b/lib/mpl_toolkits/tests/test_mplot3d.py
diff --git a/unit/ellipse_large.py b/unit/ellipse_large.py
