clip and ptp are awesome.

anntzer · anntzer · commit 654a98c415aa · 2017-06-09T19:56:32.000-07:00
diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
@@ -3397,10 +3397,11 @@ def bxp(self, bxpstats, positions=None, widths=None, vert=True,
           Sets the positions of the boxes. The ticks and limits
           are automatically set to match the positions.
 
-        widths : array-like, default = 0.5
+        widths : array-like, default = None
           Either a scalar or a vector and sets the width of each
-          box. The default is 0.5, or ``0.15*(distance between extreme
-          positions)`` if that is smaller.
+          box. The default is ``0.15*(distance between extreme
+          positions)``, clipped to no less than 0.15 and no more than
+          0.5.
 
         vert : bool, default = False
           If `True` (default), makes the boxes vertical.  If `False`,
@@ -3637,8 +3638,7 @@ def dopatch(xs, ys, **kwargs):
 
         # width
         if widths is None:
-            distance = max(positions) - min(positions)
-            widths = [min(0.15 * max(distance, 1.0), 0.5)] * N
+            widths = [np.clip(0.15 * np.ptp(positions), 0.15, 0.5)] * N
         elif np.isscalar(widths):
             widths = [widths] * N
         elif len(widths) != N:
diff --git a/lib/matplotlib/quiver.py b/lib/matplotlib/quiver.py
@@ -523,7 +523,7 @@ def _init(self):
                                             (ax.bbox.width, ax.bbox.height))
             self.span = sx
             if self.width is None:
-                sn = max(8, min(25, math.sqrt(self.N)))
+                sn = np.clip(math.sqrt(self.N), 8, 25)
                 self.width = 0.06 * self.span / sn
 
             # _make_verts sets self.scale if not already specified
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -1875,8 +1875,8 @@ def set_params(self, **kwargs):
     def _raw_ticks(self, vmin, vmax):
         if self._nbins == 'auto':
             if self.axis is not None:
-                nbins = max(min(self.axis.get_tick_space(), 9),
-                            max(1, self._min_n_ticks - 1))
+                nbins = np.clip(self.axis.get_tick_space(),
+                                max(1, self._min_n_ticks - 1), 9)
             else:
                 nbins = 9
         else:
@@ -2074,7 +2074,7 @@ def __call__(self):
     def tick_values(self, vmin, vmax):
         if self.numticks == 'auto':
             if self.axis is not None:
-                numticks = max(min(self.axis.get_tick_space(), 9), 2)
+                numticks = np.clip(self.axis.get_tick_space(), 2, 9)
             else:
                 numticks = 9
         else:
diff --git a/lib/matplotlib/tri/triinterpolate.py b/lib/matplotlib/tri/triinterpolate.py
@@ -417,10 +417,10 @@ def __init__(self, triangulation, z, kind='min_E', trifinder=None,
         self._z = self._z[~node_mask]
 
         # Computing scale factors
-        self._unit_x = np.max(compressed_x) - np.min(compressed_x)
-        self._unit_y = np.max(compressed_y) - np.min(compressed_y)
-        self._pts = np.vstack((compressed_x/float(self._unit_x),
-                               compressed_y/float(self._unit_y))).T
+        self._unit_x = np.ptp(compressed_x)
+        self._unit_y = np.ptp(compressed_y)
+        self._pts = np.column_stack([compressed_x / self._unit_x,
+                                     compressed_y / self._unit_y])
         # Computing triangle points
         self._tris_pts = self._pts[self._triangles]
         # Computing eccentricities
diff --git a/lib/matplotlib/tri/tritools.py b/lib/matplotlib/tri/tritools.py
@@ -50,11 +50,8 @@ def scale_factors(self):
         compressed_triangles = self._triangulation.get_masked_triangles()
         node_used = (np.bincount(np.ravel(compressed_triangles),
                                  minlength=self._triangulation.x.size) != 0)
-        x = self._triangulation.x[node_used]
-        y = self._triangulation.y[node_used]
-        ux = np.max(x)-np.min(x)
-        uy = np.max(y)-np.min(y)
-        return (1./float(ux), 1./float(uy))
+        return (1 / np.ptp(self._triangulation.x[node_used]),
+                1 / np.ptp(self._triangulation.y[node_used]))
 
     def circle_ratios(self, rescale=True):
         """
