Use "array" instead of "numpy array" except when emphasis is needed.

Throughout the library, array usually means "numpy array" (we also have
"array-like" for the more permissive case), so no need to repeat "numpy"
every time (I left it in when I judged that the emphasis was
reasonable).  Also some other associated docstring cleanups.

Author: anntzer

lib/matplotlib/axis.py

@@ -1511,13 +1511,13 @@ def get_ticklocs(self, *, minor=False):
 
         Returns
         -------
-        numpy array of tick locations
+        array of tick locations
         """
         return self.get_minorticklocs() if minor else self.get_majorticklocs()
 
     def get_ticks_direction(self, minor=False):
         """
-        Get the tick directions as a numpy array
+        Return an array of this Axis' tick directions.
 
         Parameters
         ----------
@@ -1527,7 +1527,7 @@ def get_ticks_direction(self, minor=False):
 
         Returns
         -------
-        numpy array of tick directions
+        array of tick directions
         """
         if minor:
             return np.array(

lib/matplotlib/backend_bases.py

@@ -694,7 +694,6 @@ def points_to_pixels(self, points):
         Parameters
         ----------
         points : float or array-like
-            a float or a numpy array of float
 
         Returns
         -------

lib/matplotlib/cbook.py

@@ -2237,7 +2237,7 @@ def _unpack_to_numpy(x):
         # If numpy, return directly
         return x
     if hasattr(x, 'to_numpy'):
-        # Assume that any function to_numpy() do actually return a numpy array
+        # Assume that any to_numpy() method actually returns a numpy array
         return x.to_numpy()
     if hasattr(x, 'values'):
         xtmp = x.values

lib/matplotlib/colors.py

@@ -2050,8 +2050,7 @@ def inverse(self, value):
 
 def rgb_to_hsv(arr):
     """
-    Convert float RGB values (in the range [0, 1]), in a numpy array to HSV
-    values.
+    Convert an array of float RGB values (in the range [0, 1]) to HSV values.
 
     Parameters
     ----------

lib/matplotlib/dates.py

@@ -383,8 +383,6 @@ def _from_ordinalf(x, tz=None):
 
 # a version of _from_ordinalf that can operate on numpy arrays
 _from_ordinalf_np_vectorized = np.vectorize(_from_ordinalf, otypes="O")
-
-
 # a version of dateutil.parser.parse that can operate on numpy arrays
 _dateutil_parser_parse_np_vectorized = np.vectorize(dateutil.parser.parse)
 

lib/matplotlib/figure.py

@@ -1928,13 +1928,11 @@ def _make_array(inp):
 
             We need to have this internal function rather than
             ``np.asarray(..., dtype=object)`` so that a list of lists
-            of lists does not get converted to an array of dimension >
-            2
+            of lists does not get converted to an array of dimension > 2.
 
             Returns
             -------
             2D object array
-
             """
             r0, *rest = inp
             if isinstance(r0, str):
@@ -1960,13 +1958,13 @@ def _identify_keys_and_nested(mosaic):
 
             Parameters
             ----------
-            mosaic : 2D numpy object array
+            mosaic : 2D object array
 
             Returns
             -------
             unique_ids : tuple
                 The unique non-sub mosaic entries in this mosaic
-            nested : dict[tuple[int, int]], 2D object array
+            nested : dict[tuple[int, int], 2D object array]
             """
             # make sure we preserve the user supplied order
             unique_ids = cbook._OrderedSet()
@@ -1990,7 +1988,7 @@ def _do_layout(gs, mosaic, unique_ids, nested):
             ----------
             gs : GridSpec
             mosaic : 2D object array
-                The input converted to a 2D numpy array for this level.
+                The input converted to a 2D array for this level.
             unique_ids : tuple
                 The identified scalar labels at this level of nesting.
             nested : dict[tuple[int, int]], 2D object array

lib/matplotlib/patches.py

@@ -1125,7 +1125,7 @@ def get_xy(self):
 
         Returns
         -------
-        (N, 2) numpy array
+        (N, 2) array
             The coordinates of the vertices.
         """
         return self._path.vertices
@@ -1164,7 +1164,7 @@ def set_xy(self, xy):
         self.stale = True
 
     xy = property(get_xy, set_xy,
-                  doc='The vertices of the path as (N, 2) numpy array.')
+                  doc='The vertices of the path as a (N, 2) array.')
 
 
 class Wedge(Patch):

lib/matplotlib/path.py

@@ -166,8 +166,8 @@ def _fast_from_codes_and_verts(cls, verts, codes, internals_from=None):
 
         Parameters
         ----------
-        verts : numpy array
-        codes : numpy array
+        verts : array-like
+        codes : array
         internals_from : Path or None
             If not None, another `Path` from which the attributes
             ``should_simplify``, ``simplify_threshold``, and
@@ -223,12 +223,12 @@ def vertices(self, vertices):
     @property
     def codes(self):
         """
-        The list of codes in the `Path` as a 1D numpy array.  Each
-        code is one of `STOP`, `MOVETO`, `LINETO`, `CURVE3`, `CURVE4`
-        or `CLOSEPOLY`.  For codes that correspond to more than one
-        vertex (`CURVE3` and `CURVE4`), that code will be repeated so
-        that the length of `vertices` and `codes` is always
-        the same.
+        The list of codes in the `Path` as a 1D array.
+
+        Each code is one of `STOP`, `MOVETO`, `LINETO`, `CURVE3`, `CURVE4` or
+        `CLOSEPOLY`.  For codes that correspond to more than one vertex
+        (`CURVE3` and `CURVE4`), that code will be repeated so that the length
+        of `vertices` and `codes` is always the same.
         """
         return self._codes
 

lib/matplotlib/textpath.py

@@ -78,19 +78,15 @@ def get_text_path(self, prop, s, ismath=False):
         ----------
         prop : `~matplotlib.font_manager.FontProperties`
             The font properties for the text.
-
         s : str
             The text to be converted.
-
         ismath : {False, True, "TeX"}
             If True, use mathtext parser.  If "TeX", use tex for rendering.
 
         Returns
         -------
         verts : list
-            A list of numpy arrays containing the x and y coordinates of the
-            vertices.
-
+            A list of arrays containing the (x, y) coordinates of the vertices.
         codes : list
             A list of path codes.
 

lib/matplotlib/transforms.py

@@ -830,11 +830,10 @@ def from_extents(*args, minpos=None):
         ----------
         left, bottom, right, top : float
             The four extents of the bounding box.
-
         minpos : float or None
-           If this is supplied, the Bbox will have a minimum positive value
-           set. This is useful when dealing with logarithmic scales and other
-           scales where negative bounds result in floating point errors.
+            If this is supplied, the Bbox will have a minimum positive value
+            set. This is useful when dealing with logarithmic scales and other
+            scales where negative bounds result in floating point errors.
         """
         bbox = Bbox(np.reshape(args, (2, 2)))
         if minpos is not None:
@@ -858,11 +857,10 @@ def ignore(self, value):
         by subsequent calls to :meth:`update_from_data_xy`.
 
         value : bool
-           - When ``True``, subsequent calls to :meth:`update_from_data_xy`
-             will ignore the existing bounds of the `Bbox`.
-
-           - When ``False``, subsequent calls to :meth:`update_from_data_xy`
-             will include the existing bounds of the `Bbox`.
+            - When ``True``, subsequent calls to `update_from_data_xy` will
+              ignore the existing bounds of the `Bbox`.
+            - When ``False``, subsequent calls to `update_from_data_xy` will
+              include the existing bounds of the `Bbox`.
         """
         self._ignore = value
 
@@ -875,12 +873,10 @@ def update_from_path(self, path, ignore=None, updatex=True, updatey=True):
         Parameters
         ----------
         path : `~matplotlib.path.Path`
-
         ignore : bool, optional
-           - when ``True``, ignore the existing bounds of the `Bbox`.
-           - when ``False``, include the existing bounds of the `Bbox`.
-           - when ``None``, use the last value passed to :meth:`ignore`.
-
+           - When ``True``, ignore the existing bounds of the `Bbox`.
+           - When ``False``, include the existing bounds of the `Bbox`.
+           - When ``None``, use the last value passed to :meth:`ignore`.
         updatex, updatey : bool, default: True
             When ``True``, update the x/y values.
         """
@@ -912,7 +908,6 @@ def update_from_data_x(self, x, ignore=None):
         ----------
         x : `~numpy.ndarray`
             Array of x-values.
-
         ignore : bool, optional
            - When ``True``, ignore the existing bounds of the `Bbox`.
            - When ``False``, include the existing bounds of the `Bbox`.
@@ -932,34 +927,32 @@ def update_from_data_y(self, y, ignore=None):
         ----------
         y : `~numpy.ndarray`
             Array of y-values.
-
         ignore : bool, optional
-           - When ``True``, ignore the existing bounds of the `Bbox`.
-           - When ``False``, include the existing bounds of the `Bbox`.
-           - When ``None``, use the last value passed to :meth:`ignore`.
+            - When ``True``, ignore the existing bounds of the `Bbox`.
+            - When ``False``, include the existing bounds of the `Bbox`.
+            - When ``None``, use the last value passed to :meth:`ignore`.
         """
         y = np.ravel(y)
         self.update_from_data_xy(np.column_stack([np.ones(y.size), y]),
                                  ignore=ignore, updatex=False)
 
     def update_from_data_xy(self, xy, ignore=None, updatex=True, updatey=True):
         """
-        Update the bounds of the `Bbox` based on the passed in data. After
-        updating, the bounds will have positive *width* and *height*;
+        Update the `Bbox` bounds based on the passed in *xy* coordinates.
+
+        After updating, the bounds will have positive *width* and *height*;
         *x0* and *y0* will be the minimal values.
 
         Parameters
         ----------
-        xy : `~numpy.ndarray`
-            A numpy array of 2D points.
-
+        xy : (N, 2) array-like
+            The (x, y) coordinates.
         ignore : bool, optional
-           - When ``True``, ignore the existing bounds of the `Bbox`.
-           - When ``False``, include the existing bounds of the `Bbox`.
-           - When ``None``, use the last value passed to :meth:`ignore`.
-
+            - When ``True``, ignore the existing bounds of the `Bbox`.
+            - When ``False``, include the existing bounds of the `Bbox`.
+            - When ``None``, use the last value passed to :meth:`ignore`.
         updatex, updatey : bool, default: True
-            When ``True``, update the x/y values.
+             When ``True``, update the x/y values.
         """
         if len(xy) == 0:
             return
@@ -1051,17 +1044,17 @@ def minposy(self):
 
     def get_points(self):
         """
-        Get the points of the bounding box directly as a numpy array
-        of the form: ``[[x0, y0], [x1, y1]]``.
+        Get the points of the bounding box as an array of the form
+        ``[[x0, y0], [x1, y1]]``.
         """
         self._invalid = 0
         return self._points
 
     def set_points(self, points):
         """
-        Set the points of the bounding box directly from a numpy array
-        of the form: ``[[x0, y0], [x1, y1]]``.  No error checking is
-        performed, as this method is mainly for internal use.
+        Set the points of the bounding box directly from an array of the form
+        ``[[x0, y0], [x1, y1]]``.  No error checking is performed, as this
+        method is mainly for internal use.
         """
         if np.any(self._points != points):
             self._points = points
@@ -1483,14 +1476,14 @@ def transform(self, values):
 
         Parameters
         ----------
-        values : array
-            The input values as NumPy array of length :attr:`input_dims` or
+        values : array-like
+            The input values as an array of length :attr:`input_dims` or
             shape (N, :attr:`input_dims`).
 
         Returns
         -------
         array
-            The output values as NumPy array of length :attr:`output_dims` or
+            The output values as an array of length :attr:`output_dims` or
             shape (N, :attr:`output_dims`), depending on the input.
         """
         # Ensure that values is a 2d array (but remember whether
@@ -1529,13 +1522,13 @@ def transform_affine(self, values):
         Parameters
         ----------
         values : array
-            The input values as NumPy array of length :attr:`input_dims` or
+            The input values as an array of length :attr:`input_dims` or
             shape (N, :attr:`input_dims`).
 
         Returns
         -------
         array
-            The output values as NumPy array of length :attr:`output_dims` or
+            The output values as an array of length :attr:`output_dims` or
             shape (N, :attr:`output_dims`), depending on the input.
         """
         return self.get_affine().transform(values)
@@ -1554,13 +1547,13 @@ def transform_non_affine(self, values):
         Parameters
         ----------
         values : array
-            The input values as NumPy array of length :attr:`input_dims` or
+            The input values as an array of length :attr:`input_dims` or
             shape (N, :attr:`input_dims`).
 
         Returns
         -------
         array
-            The output values as NumPy array of length :attr:`output_dims` or
+            The output values as an array of length :attr:`output_dims` or
             shape (N, :attr:`output_dims`), depending on the input.
         """
         return values
@@ -1932,7 +1925,7 @@ def from_values(a, b, c, d, e, f):
 
     def get_matrix(self):
         """
-        Get the underlying transformation matrix as a 3x3 numpy array::
+        Get the underlying transformation matrix as a 3x3 array::
 
           a c e
           b d f
@@ -1947,7 +1940,7 @@ def get_matrix(self):
 
     def set_matrix(self, mtx):
         """
-        Set the underlying transformation matrix from a 3x3 numpy array::
+        Set the underlying transformation matrix from a 3x3 array::
 
           a c e
           b d f