08_logisticR_code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import seaborn as sns \n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "digits = load_digits()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1797, 64)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "digits.data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X= digits.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1797,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "digits.target.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = digits.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use(\"Solarize_Light2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib in c:\\users\\junaid\\anaconda3\\lib\\site-packages (3.4.3)\n",
      "Requirement already satisfied: numpy>=1.16 in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from matplotlib) (1.20.3)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from matplotlib) (1.3.1)\n",
      "Requirement already satisfied: pillow>=6.2.0 in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from matplotlib) (8.4.0)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from matplotlib) (3.0.4)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from matplotlib) (2.8.2)\n",
      "Requirement already satisfied: cycler>=0.10 in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from matplotlib) (0.10.0)\n",
      "Requirement already satisfied: six in c:\\users\\junaid\\anaconda3\\lib\\site-packages (from cycler>=0.10->matplotlib) (1.16.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Ignoring invalid distribution -tatsmodels (c:\\users\\junaid\\anaconda3\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -tatsmodels (c:\\users\\junaid\\anaconda3\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -tatsmodels (c:\\users\\junaid\\anaconda3\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -tatsmodels (c:\\users\\junaid\\anaconda3\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -tatsmodels (c:\\users\\junaid\\anaconda3\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -tatsmodels (c:\\users\\junaid\\anaconda3\\lib\\site-packages)\n",
      "WARNING: You are using pip version 22.0.4; however, version 22.1.2 is available.\n",
      "You should consider upgrading via the 'c:\\Users\\Junaid\\anaconda3\\python.exe -m pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,4))\n",
    "for index,(image, label)in enumerate(zip(X[0:10],y[0:10])):\n",
    "    plt.subplot(1,10,index+1)\n",
    "    plt.imshow(np.reshape(image,(8,8)),cmap=plt.cm.gray)\n",
    "    plt.title(\"Training: %i\\n\" % label , fontsize = 20)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module matplotlib.pyplot in matplotlib:\n",
      "\n",
      "NAME\n",
      "    matplotlib.pyplot\n",
      "\n",
      "DESCRIPTION\n",
      "    `matplotlib.pyplot` is a state-based interface to matplotlib. It provides\n",
      "    a MATLAB-like way of plotting.\n",
      "    \n",
      "    pyplot is mainly intended for interactive plots and simple cases of\n",
      "    programmatic plot generation::\n",
      "    \n",
      "        import numpy as np\n",
      "        import matplotlib.pyplot as plt\n",
      "    \n",
      "        x = np.arange(0, 5, 0.1)\n",
      "        y = np.sin(x)\n",
      "        plt.plot(x, y)\n",
      "    \n",
      "    The object-oriented API is recommended for more complex plots.\n",
      "\n",
      "FUNCTIONS\n",
      "    acorr(x, *, data=None, **kwargs)\n",
      "        Plot the autocorrelation of *x*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array-like\n",
      "        \n",
      "        detrend : callable, default: `.mlab.detrend_none` (no detrending)\n",
      "            A detrending function applied to *x*.  It must have the\n",
      "            signature ::\n",
      "        \n",
      "                detrend(x: np.ndarray) -> np.ndarray\n",
      "        \n",
      "        normed : bool, default: True\n",
      "            If ``True``, input vectors are normalised to unit length.\n",
      "        \n",
      "        usevlines : bool, default: True\n",
      "            Determines the plot style.\n",
      "        \n",
      "            If ``True``, vertical lines are plotted from 0 to the acorr value\n",
      "            using `.Axes.vlines`. Additionally, a horizontal line is plotted\n",
      "            at y=0 using `.Axes.axhline`.\n",
      "        \n",
      "            If ``False``, markers are plotted at the acorr values using\n",
      "            `.Axes.plot`.\n",
      "        \n",
      "        maxlags : int, default: 10\n",
      "            Number of lags to show. If ``None``, will return all\n",
      "            ``2 * len(x) - 1`` lags.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lags : array (length ``2*maxlags+1``)\n",
      "            The lag vector.\n",
      "        c : array  (length ``2*maxlags+1``)\n",
      "            The auto correlation vector.\n",
      "        line : `.LineCollection` or `.Line2D`\n",
      "            `.Artist` added to the Axes of the correlation:\n",
      "        \n",
      "            - `.LineCollection` if *usevlines* is True.\n",
      "            - `.Line2D` if *usevlines* is False.\n",
      "        b : `.Line2D` or None\n",
      "            Horizontal line at 0 if *usevlines* is True\n",
      "            None *usevlines* is False.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        linestyle : `.Line2D` property, optional\n",
      "            The linestyle for plotting the data points.\n",
      "            Only used if *usevlines* is ``False``.\n",
      "        \n",
      "        marker : str, default: 'o'\n",
      "            The marker for plotting the data points.\n",
      "            Only used if *usevlines* is ``False``.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional parameters are passed to `.Axes.vlines` and\n",
      "            `.Axes.axhline` if *usevlines* is ``True``; otherwise they are\n",
      "            passed to `.Axes.plot`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cross correlation is performed with `numpy.correlate` with\n",
      "        ``mode = \"full\"``.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    angle_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)\n",
      "        Plot the angle spectrum.\n",
      "        \n",
      "        Compute the angle spectrum (wrapped phase spectrum) of *x*.\n",
      "        Data is padded to a length of *pad_to* and the windowing function\n",
      "        *window* is applied to the signal.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data.\n",
      "        \n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  While not increasing the actual resolution of the spectrum (the\n",
      "            minimum distance between resolvable peaks), this can give more points in\n",
      "            the plot, allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft().  The default is None, which sets *pad_to* equal to\n",
      "            the length of the input signal (i.e. no padding).\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 1-D array\n",
      "            The values for the angle spectrum in radians (real valued).\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *spectrum*.\n",
      "        \n",
      "        line : `~matplotlib.lines.Line2D`\n",
      "            The line created by this function.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        magnitude_spectrum\n",
      "            Plots the magnitudes of the corresponding frequencies.\n",
      "        phase_spectrum\n",
      "            Plots the unwrapped version of this function.\n",
      "        specgram\n",
      "            Can plot the angle spectrum of segments within the signal in a\n",
      "            colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    annotate(text, xy, *args, **kwargs)\n",
      "        Annotate the point *xy* with text *text*.\n",
      "        \n",
      "        In the simplest form, the text is placed at *xy*.\n",
      "        \n",
      "        Optionally, the text can be displayed in another position *xytext*.\n",
      "        An arrow pointing from the text to the annotated point *xy* can then\n",
      "        be added by defining *arrowprops*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        text : str\n",
      "            The text of the annotation.\n",
      "        \n",
      "        xy : (float, float)\n",
      "            The point *(x, y)* to annotate. The coordinate system is determined\n",
      "            by *xycoords*.\n",
      "        \n",
      "        xytext : (float, float), default: *xy*\n",
      "            The position *(x, y)* to place the text at. The coordinate system\n",
      "            is determined by *textcoords*.\n",
      "        \n",
      "        xycoords : str or `.Artist` or `.Transform` or callable or (float, float), default: 'data'\n",
      "        \n",
      "            The coordinate system that *xy* is given in. The following types\n",
      "            of values are supported:\n",
      "        \n",
      "            - One of the following strings:\n",
      "        \n",
      "              ==================== ============================================\n",
      "              Value                Description\n",
      "              ==================== ============================================\n",
      "              'figure points'      Points from the lower left of the figure\n",
      "              'figure pixels'      Pixels from the lower left of the figure\n",
      "              'figure fraction'    Fraction of figure from lower left\n",
      "              'subfigure points'   Points from the lower left of the subfigure\n",
      "              'subfigure pixels'   Pixels from the lower left of the subfigure\n",
      "              'subfigure fraction' Fraction of subfigure from lower left\n",
      "              'axes points'        Points from lower left corner of axes\n",
      "              'axes pixels'        Pixels from lower left corner of axes\n",
      "              'axes fraction'      Fraction of axes from lower left\n",
      "              'data'               Use the coordinate system of the object\n",
      "                                   being annotated (default)\n",
      "              'polar'              *(theta, r)* if not native 'data'\n",
      "                                   coordinates\n",
      "              ==================== ============================================\n",
      "        \n",
      "              Note that 'subfigure pixels' and 'figure pixels' are the same\n",
      "              for the parent figure, so users who want code that is usable in\n",
      "              a subfigure can use 'subfigure pixels'.\n",
      "        \n",
      "            - An `.Artist`: *xy* is interpreted as a fraction of the artist's\n",
      "              `~matplotlib.transforms.Bbox`. E.g. *(0, 0)* would be the lower\n",
      "              left corner of the bounding box and *(0.5, 1)* would be the\n",
      "              center top of the bounding box.\n",
      "        \n",
      "            - A `.Transform` to transform *xy* to screen coordinates.\n",
      "        \n",
      "            - A function with one of the following signatures::\n",
      "        \n",
      "                def transform(renderer) -> Bbox\n",
      "                def transform(renderer) -> Transform\n",
      "        \n",
      "              where *renderer* is a `.RendererBase` subclass.\n",
      "        \n",
      "              The result of the function is interpreted like the `.Artist` and\n",
      "              `.Transform` cases above.\n",
      "        \n",
      "            - A tuple *(xcoords, ycoords)* specifying separate coordinate\n",
      "              systems for *x* and *y*. *xcoords* and *ycoords* must each be\n",
      "              of one of the above described types.\n",
      "        \n",
      "            See :ref:`plotting-guide-annotation` for more details.\n",
      "        \n",
      "        textcoords : str or `.Artist` or `.Transform` or callable or (float, float), default: value of *xycoords*\n",
      "            The coordinate system that *xytext* is given in.\n",
      "        \n",
      "            All *xycoords* values are valid as well as the following\n",
      "            strings:\n",
      "        \n",
      "            =================   =========================================\n",
      "            Value               Description\n",
      "            =================   =========================================\n",
      "            'offset points'     Offset (in points) from the *xy* value\n",
      "            'offset pixels'     Offset (in pixels) from the *xy* value\n",
      "            =================   =========================================\n",
      "        \n",
      "        arrowprops : dict, optional\n",
      "            The properties used to draw a `.FancyArrowPatch` arrow between the\n",
      "            positions *xy* and *xytext*. Note that the edge of the arrow\n",
      "            pointing to *xytext* will be centered on the text itself and may\n",
      "            not point directly to the coordinates given in *xytext*.\n",
      "        \n",
      "            If *arrowprops* does not contain the key 'arrowstyle' the\n",
      "            allowed keys are:\n",
      "        \n",
      "            ==========   ======================================================\n",
      "            Key          Description\n",
      "            ==========   ======================================================\n",
      "            width        The width of the arrow in points\n",
      "            headwidth    The width of the base of the arrow head in points\n",
      "            headlength   The length of the arrow head in points\n",
      "            shrink       Fraction of total length to shrink from both ends\n",
      "            ?            Any key to :class:`matplotlib.patches.FancyArrowPatch`\n",
      "            ==========   ======================================================\n",
      "        \n",
      "            If *arrowprops* contains the key 'arrowstyle' the\n",
      "            above keys are forbidden.  The allowed values of\n",
      "            ``'arrowstyle'`` are:\n",
      "        \n",
      "            ============   =============================================\n",
      "            Name           Attrs\n",
      "            ============   =============================================\n",
      "            ``'-'``        None\n",
      "            ``'->'``       head_length=0.4,head_width=0.2\n",
      "            ``'-['``       widthB=1.0,lengthB=0.2,angleB=None\n",
      "            ``'|-|'``      widthA=1.0,widthB=1.0\n",
      "            ``'-|>'``      head_length=0.4,head_width=0.2\n",
      "            ``'<-'``       head_length=0.4,head_width=0.2\n",
      "            ``'<->'``      head_length=0.4,head_width=0.2\n",
      "            ``'<|-'``      head_length=0.4,head_width=0.2\n",
      "            ``'<|-|>'``    head_length=0.4,head_width=0.2\n",
      "            ``'fancy'``    head_length=0.4,head_width=0.4,tail_width=0.4\n",
      "            ``'simple'``   head_length=0.5,head_width=0.5,tail_width=0.2\n",
      "            ``'wedge'``    tail_width=0.3,shrink_factor=0.5\n",
      "            ============   =============================================\n",
      "        \n",
      "            Valid keys for `~matplotlib.patches.FancyArrowPatch` are:\n",
      "        \n",
      "            ===============  ==================================================\n",
      "            Key              Description\n",
      "            ===============  ==================================================\n",
      "            arrowstyle       the arrow style\n",
      "            connectionstyle  the connection style\n",
      "            relpos           default is (0.5, 0.5)\n",
      "            patchA           default is bounding box of the text\n",
      "            patchB           default is None\n",
      "            shrinkA          default is 2 points\n",
      "            shrinkB          default is 2 points\n",
      "            mutation_scale   default is text size (in points)\n",
      "            mutation_aspect  default is 1.\n",
      "            ?                any key for :class:`matplotlib.patches.PathPatch`\n",
      "            ===============  ==================================================\n",
      "        \n",
      "            Defaults to None, i.e. no arrow is drawn.\n",
      "        \n",
      "        annotation_clip : bool or None, default: None\n",
      "            Whether to draw the annotation when the annotation point *xy* is\n",
      "            outside the axes area.\n",
      "        \n",
      "            - If *True*, the annotation will only be drawn when *xy* is\n",
      "              within the axes.\n",
      "            - If *False*, the annotation will always be drawn.\n",
      "            - If *None*, the annotation will only be drawn when *xy* is\n",
      "              within the axes and *xycoords* is 'data'.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional kwargs are passed to `~matplotlib.text.Text`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.Annotation`\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :ref:`plotting-guide-annotation`\n",
      "    \n",
      "    arrow(x, y, dx, dy, **kwargs)\n",
      "        Add an arrow to the Axes.\n",
      "        \n",
      "        This draws an arrow from ``(x, y)`` to ``(x+dx, y+dy)``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : float\n",
      "            The x and y coordinates of the arrow base.\n",
      "        \n",
      "        dx, dy : float\n",
      "            The length of the arrow along x and y direction.\n",
      "        \n",
      "        width : float, default: 0.001\n",
      "            Width of full arrow tail.\n",
      "        \n",
      "        length_includes_head : bool, default: False\n",
      "            True if head is to be counted in calculating the length.\n",
      "        \n",
      "        head_width : float or None, default: 3*width\n",
      "            Total width of the full arrow head.\n",
      "        \n",
      "        head_length : float or None, default: 1.5*head_width\n",
      "            Length of arrow head.\n",
      "        \n",
      "        shape : {'full', 'left', 'right'}, default: 'full'\n",
      "            Draw the left-half, right-half, or full arrow.\n",
      "        \n",
      "        overhang : float, default: 0\n",
      "            Fraction that the arrow is swept back (0 overhang means\n",
      "            triangular shape). Can be negative or greater than one.\n",
      "        \n",
      "        head_starts_at_zero : bool, default: False\n",
      "            If True, the head starts being drawn at coordinate 0\n",
      "            instead of ending at coordinate 0.\n",
      "        \n",
      "        **kwargs\n",
      "            `.Patch` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: unknown\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color: color\n",
      "            contains: unknown\n",
      "            edgecolor or ec: color or None or 'auto'\n",
      "            facecolor or fc: color or None\n",
      "            figure: `.Figure`\n",
      "            fill: bool\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float or None\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.FancyArrow`\n",
      "            The created `.FancyArrow` object.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The resulting arrow is affected by the Axes aspect ratio and limits.\n",
      "        This may produce an arrow whose head is not square with its stem. To\n",
      "        create an arrow whose head is square with its stem,\n",
      "        use :meth:`annotate` for example:\n",
      "        \n",
      "        >>> ax.annotate(\"\", xy=(0.5, 0.5), xytext=(0, 0),\n",
      "        ...             arrowprops=dict(arrowstyle=\"->\"))\n",
      "    \n",
      "    autoscale(enable=True, axis='both', tight=None)\n",
      "        Autoscale the axis view to the data (toggle).\n",
      "        \n",
      "        Convenience method for simple axis view autoscaling.\n",
      "        It turns autoscaling on or off, and then,\n",
      "        if autoscaling for either axis is on, it performs\n",
      "        the autoscaling on the specified axis or axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        enable : bool or None, default: True\n",
      "            True turns autoscaling on, False turns it off.\n",
      "            None leaves the autoscaling state unchanged.\n",
      "        axis : {'both', 'x', 'y'}, default: 'both'\n",
      "            Which axis to operate on.\n",
      "        tight : bool or None, default: None\n",
      "            If True, first set the margins to zero.  Then, this argument is\n",
      "            forwarded to `autoscale_view` (regardless of its value); see the\n",
      "            description of its behavior there.\n",
      "    \n",
      "    autumn()\n",
      "        Set the colormap to 'autumn'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    axes(arg=None, **kwargs)\n",
      "        Add an axes to the current figure and make it the current axes.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            plt.axes()\n",
      "            plt.axes(rect, projection=None, polar=False, **kwargs)\n",
      "            plt.axes(ax)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        arg : None or 4-tuple\n",
      "            The exact behavior of this function depends on the type:\n",
      "        \n",
      "            - *None*: A new full window axes is added using\n",
      "              ``subplot(**kwargs)``.\n",
      "            - 4-tuple of floats *rect* = ``[left, bottom, width, height]``.\n",
      "              A new axes is added with dimensions *rect* in normalized\n",
      "              (0, 1) units using `~.Figure.add_axes` on the current figure.\n",
      "        \n",
      "        projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', 'rectilinear', str}, optional\n",
      "            The projection type of the `~.axes.Axes`. *str* is the name of\n",
      "            a custom projection, see `~matplotlib.projections`. The default\n",
      "            None results in a 'rectilinear' projection.\n",
      "        \n",
      "        polar : bool, default: False\n",
      "            If True, equivalent to projection='polar'.\n",
      "        \n",
      "        sharex, sharey : `~.axes.Axes`, optional\n",
      "            Share the x or y `~matplotlib.axis` with sharex and/or sharey.\n",
      "            The axis will have the same limits, ticks, and scale as the axis\n",
      "            of the shared axes.\n",
      "        \n",
      "        label : str\n",
      "            A label for the returned axes.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~.axes.Axes`, or a subclass of `~.axes.Axes`\n",
      "            The returned axes class depends on the projection used. It is\n",
      "            `~.axes.Axes` if rectilinear projection is used and\n",
      "            `.projections.polar.PolarAxes` if polar projection is used.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            This method also takes the keyword arguments for\n",
      "            the returned axes class. The keyword arguments for the\n",
      "            rectilinear axes class `~.axes.Axes` can be found in\n",
      "            the following table but there might also be other keyword\n",
      "            arguments if another projection is used, see the actual axes\n",
      "            class.\n",
      "        \n",
      "            Properties:\n",
      "            adjustable: {'box', 'datalim'}\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}\n",
      "            animated: bool\n",
      "            aspect: {'auto', 'equal'} or float\n",
      "            autoscale_on: bool\n",
      "            autoscalex_on: bool\n",
      "            autoscaley_on: bool\n",
      "            axes_locator: Callable[[Axes, Renderer], Bbox]\n",
      "            axisbelow: bool or 'line'\n",
      "            box_aspect: float or None\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            contains: unknown\n",
      "            facecolor or fc: color\n",
      "            figure: `.Figure`\n",
      "            frame_on: bool\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            navigate: bool\n",
      "            navigate_mode: unknown\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n",
      "            prop_cycle: unknown\n",
      "            rasterization_zorder: float or None\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            title: str\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xbound: unknown\n",
      "            xlabel: str\n",
      "            xlim: (bottom: float, top: float)\n",
      "            xmargin: float greater than -0.5\n",
      "            xscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            xticklabels: unknown\n",
      "            xticks: unknown\n",
      "            ybound: unknown\n",
      "            ylabel: str\n",
      "            ylim: (bottom: float, top: float)\n",
      "            ymargin: float greater than -0.5\n",
      "            yscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            yticklabels: unknown\n",
      "            yticks: unknown\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If the figure already has a axes with key (*args*,\n",
      "        *kwargs*) then it will simply make that axes current and\n",
      "        return it.  This behavior is deprecated. Meanwhile, if you do\n",
      "        not want this behavior (i.e., you want to force the creation of a\n",
      "        new axes), you must use a unique set of args and kwargs.  The axes\n",
      "        *label* attribute has been exposed for this purpose: if you want\n",
      "        two axes that are otherwise identical to be added to the figure,\n",
      "        make sure you give them unique labels.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .Figure.add_axes\n",
      "        .pyplot.subplot\n",
      "        .Figure.add_subplot\n",
      "        .Figure.subplots\n",
      "        .pyplot.subplots\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            # Creating a new full window axes\n",
      "            plt.axes()\n",
      "        \n",
      "            # Creating a new axes with specified dimensions and some kwargs\n",
      "            plt.axes((left, bottom, width, height), facecolor='w')\n",
      "    \n",
      "    axhline(y=0, xmin=0, xmax=1, **kwargs)\n",
      "        Add a horizontal line across the axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : float, default: 0\n",
      "            y position in data coordinates of the horizontal line.\n",
      "        \n",
      "        xmin : float, default: 0\n",
      "            Should be between 0 and 1, 0 being the far left of the plot, 1 the\n",
      "            far right of the plot.\n",
      "        \n",
      "        xmax : float, default: 1\n",
      "            Should be between 0 and 1, 0 being the far left of the plot, 1 the\n",
      "            far right of the plot.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.lines.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Valid keyword arguments are `.Line2D` properties, with the\n",
      "            exception of 'transform':\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        hlines : Add horizontal lines in data coordinates.\n",
      "        axhspan : Add a horizontal span (rectangle) across the axis.\n",
      "        axline : Add a line with an arbitrary slope.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        * draw a thick red hline at 'y' = 0 that spans the xrange::\n",
      "        \n",
      "            >>> axhline(linewidth=4, color='r')\n",
      "        \n",
      "        * draw a default hline at 'y' = 1 that spans the xrange::\n",
      "        \n",
      "            >>> axhline(y=1)\n",
      "        \n",
      "        * draw a default hline at 'y' = .5 that spans the middle half of\n",
      "          the xrange::\n",
      "        \n",
      "            >>> axhline(y=.5, xmin=0.25, xmax=0.75)\n",
      "    \n",
      "    axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs)\n",
      "        Add a horizontal span (rectangle) across the Axes.\n",
      "        \n",
      "        The rectangle spans from *ymin* to *ymax* vertically, and, by default,\n",
      "        the whole x-axis horizontally.  The x-span can be set using *xmin*\n",
      "        (default: 0) and *xmax* (default: 1) which are in axis units; e.g.\n",
      "        ``xmin = 0.5`` always refers to the middle of the x-axis regardless of\n",
      "        the limits set by `~.Axes.set_xlim`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ymin : float\n",
      "            Lower y-coordinate of the span, in data units.\n",
      "        ymax : float\n",
      "            Upper y-coordinate of the span, in data units.\n",
      "        xmin : float, default: 0\n",
      "            Lower x-coordinate of the span, in x-axis (0-1) units.\n",
      "        xmax : float, default: 1\n",
      "            Upper x-coordinate of the span, in x-axis (0-1) units.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.patches.Polygon`\n",
      "            Horizontal span (rectangle) from (xmin, ymin) to (xmax, ymax).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Polygon` properties\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: unknown\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color: color\n",
      "            contains: unknown\n",
      "            edgecolor or ec: color or None or 'auto'\n",
      "            facecolor or fc: color or None\n",
      "            figure: `.Figure`\n",
      "            fill: bool\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float or None\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        axvspan : Add a vertical span across the Axes.\n",
      "    \n",
      "    axis(*args, emit=True, **kwargs)\n",
      "        Convenience method to get or set some axis properties.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          xmin, xmax, ymin, ymax = axis()\n",
      "          xmin, xmax, ymin, ymax = axis([xmin, xmax, ymin, ymax])\n",
      "          xmin, xmax, ymin, ymax = axis(option)\n",
      "          xmin, xmax, ymin, ymax = axis(**kwargs)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xmin, xmax, ymin, ymax : float, optional\n",
      "            The axis limits to be set.  This can also be achieved using ::\n",
      "        \n",
      "                ax.set(xlim=(xmin, xmax), ylim=(ymin, ymax))\n",
      "        \n",
      "        option : bool or str\n",
      "            If a bool, turns axis lines and labels on or off. If a string,\n",
      "            possible values are:\n",
      "        \n",
      "            ======== ==========================================================\n",
      "            Value    Description\n",
      "            ======== ==========================================================\n",
      "            'on'     Turn on axis lines and labels. Same as ``True``.\n",
      "            'off'    Turn off axis lines and labels. Same as ``False``.\n",
      "            'equal'  Set equal scaling (i.e., make circles circular) by\n",
      "                     changing axis limits. This is the same as\n",
      "                     ``ax.set_aspect('equal', adjustable='datalim')``.\n",
      "                     Explicit data limits may not be respected in this case.\n",
      "            'scaled' Set equal scaling (i.e., make circles circular) by\n",
      "                     changing dimensions of the plot box. This is the same as\n",
      "                     ``ax.set_aspect('equal', adjustable='box', anchor='C')``.\n",
      "                     Additionally, further autoscaling will be disabled.\n",
      "            'tight'  Set limits just large enough to show all data, then\n",
      "                     disable further autoscaling.\n",
      "            'auto'   Automatic scaling (fill plot box with data).\n",
      "            'image'  'scaled' with axis limits equal to data limits.\n",
      "            'square' Square plot; similar to 'scaled', but initially forcing\n",
      "                     ``xmax-xmin == ymax-ymin``.\n",
      "            ======== ==========================================================\n",
      "        \n",
      "        emit : bool, default: True\n",
      "            Whether observers are notified of the axis limit change.\n",
      "            This option is passed on to `~.Axes.set_xlim` and\n",
      "            `~.Axes.set_ylim`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xmin, xmax, ymin, ymax : float\n",
      "            The axis limits.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.axes.Axes.set_xlim\n",
      "        matplotlib.axes.Axes.set_ylim\n",
      "    \n",
      "    axline(xy1, xy2=None, *, slope=None, **kwargs)\n",
      "        Add an infinitely long straight line.\n",
      "        \n",
      "        The line can be defined either by two points *xy1* and *xy2*, or\n",
      "        by one point *xy1* and a *slope*.\n",
      "        \n",
      "        This draws a straight line \"on the screen\", regardless of the x and y\n",
      "        scales, and is thus also suitable for drawing exponential decays in\n",
      "        semilog plots, power laws in loglog plots, etc. However, *slope*\n",
      "        should only be used with linear scales; It has no clear meaning for\n",
      "        all other scales, and thus the behavior is undefined. Please specify\n",
      "        the line using the points *xy1*, *xy2* for non-linear scales.\n",
      "        \n",
      "        The *transform* keyword argument only applies to the points *xy1*,\n",
      "        *xy2*. The *slope* (if given) is always in data coordinates. This can\n",
      "        be used e.g. with ``ax.transAxes`` for drawing grid lines with a fixed\n",
      "        slope.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xy1, xy2 : (float, float)\n",
      "            Points for the line to pass through.\n",
      "            Either *xy2* or *slope* has to be given.\n",
      "        slope : float, optional\n",
      "            The slope of the line. Either *xy2* or *slope* has to be given.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Valid kwargs are `.Line2D` properties\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        axhline : for horizontal lines\n",
      "        axvline : for vertical lines\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw a thick red line passing through (0, 0) and (1, 1)::\n",
      "        \n",
      "            >>> axline((0, 0), (1, 1), linewidth=4, color='r')\n",
      "    \n",
      "    axvline(x=0, ymin=0, ymax=1, **kwargs)\n",
      "        Add a vertical line across the Axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : float, default: 0\n",
      "            x position in data coordinates of the vertical line.\n",
      "        \n",
      "        ymin : float, default: 0\n",
      "            Should be between 0 and 1, 0 being the bottom of the plot, 1 the\n",
      "            top of the plot.\n",
      "        \n",
      "        ymax : float, default: 1\n",
      "            Should be between 0 and 1, 0 being the bottom of the plot, 1 the\n",
      "            top of the plot.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.lines.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Valid keyword arguments are `.Line2D` properties, with the\n",
      "            exception of 'transform':\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        vlines : Add vertical lines in data coordinates.\n",
      "        axvspan : Add a vertical span (rectangle) across the axis.\n",
      "        axline : Add a line with an arbitrary slope.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        * draw a thick red vline at *x* = 0 that spans the yrange::\n",
      "        \n",
      "            >>> axvline(linewidth=4, color='r')\n",
      "        \n",
      "        * draw a default vline at *x* = 1 that spans the yrange::\n",
      "        \n",
      "            >>> axvline(x=1)\n",
      "        \n",
      "        * draw a default vline at *x* = .5 that spans the middle half of\n",
      "          the yrange::\n",
      "        \n",
      "            >>> axvline(x=.5, ymin=0.25, ymax=0.75)\n",
      "    \n",
      "    axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs)\n",
      "        Add a vertical span (rectangle) across the Axes.\n",
      "        \n",
      "        The rectangle spans from *xmin* to *xmax* horizontally, and, by\n",
      "        default, the whole y-axis vertically.  The y-span can be set using\n",
      "        *ymin* (default: 0) and *ymax* (default: 1) which are in axis units;\n",
      "        e.g. ``ymin = 0.5`` always refers to the middle of the y-axis\n",
      "        regardless of the limits set by `~.Axes.set_ylim`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xmin : float\n",
      "            Lower x-coordinate of the span, in data units.\n",
      "        xmax : float\n",
      "            Upper x-coordinate of the span, in data units.\n",
      "        ymin : float, default: 0\n",
      "            Lower y-coordinate of the span, in y-axis units (0-1).\n",
      "        ymax : float, default: 1\n",
      "            Upper y-coordinate of the span, in y-axis units (0-1).\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.patches.Polygon`\n",
      "            Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Polygon` properties\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: unknown\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color: color\n",
      "            contains: unknown\n",
      "            edgecolor or ec: color or None or 'auto'\n",
      "            facecolor or fc: color or None\n",
      "            figure: `.Figure`\n",
      "            fill: bool\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float or None\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        axhspan : Add a horizontal span across the Axes.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw a vertical, green, translucent rectangle from x = 1.25 to\n",
      "        x = 1.55 that spans the yrange of the Axes.\n",
      "        \n",
      "        >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)\n",
      "    \n",
      "    bar(x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs)\n",
      "        Make a bar plot.\n",
      "        \n",
      "        The bars are positioned at *x* with the given *align*\\ment. Their\n",
      "        dimensions are given by *height* and *width*. The vertical baseline\n",
      "        is *bottom* (default 0).\n",
      "        \n",
      "        Many parameters can take either a single value applying to all bars\n",
      "        or a sequence of values, one for each bar.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : float or array-like\n",
      "            The x coordinates of the bars. See also *align* for the\n",
      "            alignment of the bars to the coordinates.\n",
      "        \n",
      "        height : float or array-like\n",
      "            The height(s) of the bars.\n",
      "        \n",
      "        width : float or array-like, default: 0.8\n",
      "            The width(s) of the bars.\n",
      "        \n",
      "        bottom : float or array-like, default: 0\n",
      "            The y coordinate(s) of the bars bases.\n",
      "        \n",
      "        align : {'center', 'edge'}, default: 'center'\n",
      "            Alignment of the bars to the *x* coordinates:\n",
      "        \n",
      "            - 'center': Center the base on the *x* positions.\n",
      "            - 'edge': Align the left edges of the bars with the *x* positions.\n",
      "        \n",
      "            To align the bars on the right edge pass a negative *width* and\n",
      "            ``align='edge'``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.BarContainer`\n",
      "            Container with all the bars and optionally errorbars.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        color : color or list of color, optional\n",
      "            The colors of the bar faces.\n",
      "        \n",
      "        edgecolor : color or list of color, optional\n",
      "            The colors of the bar edges.\n",
      "        \n",
      "        linewidth : float or array-like, optional\n",
      "            Width of the bar edge(s). If 0, don't draw edges.\n",
      "        \n",
      "        tick_label : str or list of str, optional\n",
      "            The tick labels of the bars.\n",
      "            Default: None (Use default numeric labels.)\n",
      "        \n",
      "        xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional\n",
      "            If not *None*, add horizontal / vertical errorbars to the bar tips.\n",
      "            The values are +/- sizes relative to the data:\n",
      "        \n",
      "            - scalar: symmetric +/- values for all bars\n",
      "            - shape(N,): symmetric +/- values for each bar\n",
      "            - shape(2, N): Separate - and + values for each bar. First row\n",
      "              contains the lower errors, the second row contains the upper\n",
      "              errors.\n",
      "            - *None*: No errorbar. (Default)\n",
      "        \n",
      "            See :doc:`/gallery/statistics/errorbar_features`\n",
      "            for an example on the usage of ``xerr`` and ``yerr``.\n",
      "        \n",
      "        ecolor : color or list of color, default: 'black'\n",
      "            The line color of the errorbars.\n",
      "        \n",
      "        capsize : float, default: :rc:`errorbar.capsize`\n",
      "           The length of the error bar caps in points.\n",
      "        \n",
      "        error_kw : dict, optional\n",
      "            Dictionary of kwargs to be passed to the `~.Axes.errorbar`\n",
      "            method. Values of *ecolor* or *capsize* defined here take\n",
      "            precedence over the independent kwargs.\n",
      "        \n",
      "        log : bool, default: False\n",
      "            If *True*, set the y-axis to be log scale.\n",
      "        \n",
      "        **kwargs : `.Rectangle` properties\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: unknown\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color: color\n",
      "            contains: unknown\n",
      "            edgecolor or ec: color or None or 'auto'\n",
      "            facecolor or fc: color or None\n",
      "            figure: `.Figure`\n",
      "            fill: bool\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float or None\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        barh : Plot a horizontal bar plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Stacked bars can be achieved by passing individual *bottom* values per\n",
      "        bar. See :doc:`/gallery/lines_bars_and_markers/bar_stacked`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    bar_label(container, labels=None, *, fmt='%g', label_type='edge', padding=0, **kwargs)\n",
      "        Label a bar plot.\n",
      "        \n",
      "        Adds labels to bars in the given `.BarContainer`.\n",
      "        You may need to adjust the axis limits to fit the labels.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        container : `.BarContainer`\n",
      "            Container with all the bars and optionally errorbars, likely\n",
      "            returned from `.bar` or `.barh`.\n",
      "        \n",
      "        labels : array-like, optional\n",
      "            A list of label texts, that should be displayed. If not given, the\n",
      "            label texts will be the data values formatted with *fmt*.\n",
      "        \n",
      "        fmt : str, default: '%g'\n",
      "            A format string for the label.\n",
      "        \n",
      "        label_type : {'edge', 'center'}, default: 'edge'\n",
      "            The label type. Possible values:\n",
      "        \n",
      "            - 'edge': label placed at the end-point of the bar segment, and the\n",
      "              value displayed will be the position of that end-point.\n",
      "            - 'center': label placed in the center of the bar segment, and the\n",
      "              value displayed will be the length of that segment.\n",
      "              (useful for stacked bars, i.e.,\n",
      "              :doc:`/gallery/lines_bars_and_markers/bar_label_demo`)\n",
      "        \n",
      "        padding : float, default: 0\n",
      "            Distance of label from the end of the bar, in points.\n",
      "        \n",
      "        **kwargs\n",
      "            Any remaining keyword arguments are passed through to\n",
      "            `.Axes.annotate`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `.Text`\n",
      "            A list of `.Text` instances for the labels.\n",
      "    \n",
      "    barbs(*args, data=None, **kw)\n",
      "        Plot a 2D field of barbs.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          barbs([X, Y], U, V, [C], **kw)\n",
      "        \n",
      "        Where *X*, *Y* define the barb locations, *U*, *V* define the barb\n",
      "        directions, and *C* optionally sets the color.\n",
      "        \n",
      "        All arguments may be 1D or 2D. *U*, *V*, *C* may be masked arrays, but masked\n",
      "        *X*, *Y* are not supported at present.\n",
      "        \n",
      "        Barbs are traditionally used in meteorology as a way to plot the speed\n",
      "        and direction of wind observations, but can technically be used to\n",
      "        plot any two dimensional vector quantity.  As opposed to arrows, which\n",
      "        give vector magnitude by the length of the arrow, the barbs give more\n",
      "        quantitative information about the vector magnitude by putting slanted\n",
      "        lines or a triangle for various increments in magnitude, as show\n",
      "        schematically below::\n",
      "        \n",
      "          :                   /\\    \\\n",
      "          :                  /  \\    \\\n",
      "          :                 /    \\    \\    \\\n",
      "          :                /      \\    \\    \\\n",
      "          :               ------------------------------\n",
      "        \n",
      "        The largest increment is given by a triangle (or \"flag\"). After those\n",
      "        come full lines (barbs). The smallest increment is a half line.  There\n",
      "        is only, of course, ever at most 1 half line.  If the magnitude is\n",
      "        small and only needs a single half-line and no full lines or\n",
      "        triangles, the half-line is offset from the end of the barb so that it\n",
      "        can be easily distinguished from barbs with a single full line.  The\n",
      "        magnitude for the barb shown above would nominally be 65, using the\n",
      "        standard increments of 50, 10, and 5.\n",
      "        \n",
      "        See also https://en.wikipedia.org/wiki/Wind_barb.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X, Y : 1D or 2D array-like, optional\n",
      "            The x and y coordinates of the barb locations. See *pivot* for how the\n",
      "            barbs are drawn to the x, y positions.\n",
      "        \n",
      "            If not given, they will be generated as a uniform integer meshgrid based\n",
      "            on the dimensions of *U* and *V*.\n",
      "        \n",
      "            If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D\n",
      "            using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``\n",
      "            must match the column and row dimensions of *U* and *V*.\n",
      "        \n",
      "        U, V : 1D or 2D array-like\n",
      "            The x and y components of the barb shaft.\n",
      "        \n",
      "        C : 1D or 2D array-like, optional\n",
      "            Numeric data that defines the barb colors by colormapping via *norm* and\n",
      "            *cmap*.\n",
      "        \n",
      "            This does not support explicit colors. If you want to set colors directly,\n",
      "            use *barbcolor* instead.\n",
      "        \n",
      "        length : float, default: 7\n",
      "            Length of the barb in points; the other parts of the barb\n",
      "            are scaled against this.\n",
      "        \n",
      "        pivot : {'tip', 'middle'} or float, default: 'tip'\n",
      "            The part of the arrow that is anchored to the *X*, *Y* grid. The barb\n",
      "            rotates about this point. This can also be a number, which shifts the\n",
      "            start of the barb that many points away from grid point.\n",
      "        \n",
      "        barbcolor : color or color sequence\n",
      "            The color of all parts of the barb except for the flags.  This parameter\n",
      "            is analogous to the *edgecolor* parameter for polygons, which can be used\n",
      "            instead. However this parameter will override facecolor.\n",
      "        \n",
      "        flagcolor : color or color sequence\n",
      "            The color of any flags on the barb.  This parameter is analogous to the\n",
      "            *facecolor* parameter for polygons, which can be used instead. However,\n",
      "            this parameter will override facecolor.  If this is not set (and *C* has\n",
      "            not either) then *flagcolor* will be set to match *barbcolor* so that the\n",
      "            barb has a uniform color. If *C* has been set, *flagcolor* has no effect.\n",
      "        \n",
      "        sizes : dict, optional\n",
      "            A dictionary of coefficients specifying the ratio of a given\n",
      "            feature to the length of the barb. Only those values one wishes to\n",
      "            override need to be included.  These features include:\n",
      "        \n",
      "            - 'spacing' - space between features (flags, full/half barbs)\n",
      "            - 'height' - height (distance from shaft to top) of a flag or full barb\n",
      "            - 'width' - width of a flag, twice the width of a full barb\n",
      "            - 'emptybarb' - radius of the circle used for low magnitudes\n",
      "        \n",
      "        fill_empty : bool, default: False\n",
      "            Whether the empty barbs (circles) that are drawn should be filled with\n",
      "            the flag color.  If they are not filled, the center is transparent.\n",
      "        \n",
      "        rounding : bool, default: True\n",
      "            Whether the vector magnitude should be rounded when allocating barb\n",
      "            components.  If True, the magnitude is rounded to the nearest multiple\n",
      "            of the half-barb increment.  If False, the magnitude is simply truncated\n",
      "            to the next lowest multiple.\n",
      "        \n",
      "        barb_increments : dict, optional\n",
      "            A dictionary of increments specifying values to associate with\n",
      "            different parts of the barb. Only those values one wishes to\n",
      "            override need to be included.\n",
      "        \n",
      "            - 'half' - half barbs (Default is 5)\n",
      "            - 'full' - full barbs (Default is 10)\n",
      "            - 'flag' - flags (default is 50)\n",
      "        \n",
      "        flip_barb : bool or array-like of bool, default: False\n",
      "            Whether the lines and flags should point opposite to normal.\n",
      "            Normal behavior is for the barbs and lines to point right (comes from wind\n",
      "            barbs having these features point towards low pressure in the Northern\n",
      "            Hemisphere).\n",
      "        \n",
      "            A single value is applied to all barbs. Individual barbs can be flipped by\n",
      "            passing a bool array of the same size as *U* and *V*.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        barbs : `~matplotlib.quiver.Barbs`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            The barbs can further be customized using `.PolyCollection` keyword\n",
      "            arguments:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    barh(y, width, height=0.8, left=None, *, align='center', **kwargs)\n",
      "        Make a horizontal bar plot.\n",
      "        \n",
      "        The bars are positioned at *y* with the given *align*\\ment. Their\n",
      "        dimensions are given by *width* and *height*. The horizontal baseline\n",
      "        is *left* (default 0).\n",
      "        \n",
      "        Many parameters can take either a single value applying to all bars\n",
      "        or a sequence of values, one for each bar.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : float or array-like\n",
      "            The y coordinates of the bars. See also *align* for the\n",
      "            alignment of the bars to the coordinates.\n",
      "        \n",
      "        width : float or array-like\n",
      "            The width(s) of the bars.\n",
      "        \n",
      "        height : float or array-like, default: 0.8\n",
      "            The heights of the bars.\n",
      "        \n",
      "        left : float or array-like, default: 0\n",
      "            The x coordinates of the left sides of the bars.\n",
      "        \n",
      "        align : {'center', 'edge'}, default: 'center'\n",
      "            Alignment of the base to the *y* coordinates*:\n",
      "        \n",
      "            - 'center': Center the bars on the *y* positions.\n",
      "            - 'edge': Align the bottom edges of the bars with the *y*\n",
      "              positions.\n",
      "        \n",
      "            To align the bars on the top edge pass a negative *height* and\n",
      "            ``align='edge'``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.BarContainer`\n",
      "            Container with all the bars and optionally errorbars.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        color : color or list of color, optional\n",
      "            The colors of the bar faces.\n",
      "        \n",
      "        edgecolor : color or list of color, optional\n",
      "            The colors of the bar edges.\n",
      "        \n",
      "        linewidth : float or array-like, optional\n",
      "            Width of the bar edge(s). If 0, don't draw edges.\n",
      "        \n",
      "        tick_label : str or list of str, optional\n",
      "            The tick labels of the bars.\n",
      "            Default: None (Use default numeric labels.)\n",
      "        \n",
      "        xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional\n",
      "            If not ``None``, add horizontal / vertical errorbars to the\n",
      "            bar tips. The values are +/- sizes relative to the data:\n",
      "        \n",
      "            - scalar: symmetric +/- values for all bars\n",
      "            - shape(N,): symmetric +/- values for each bar\n",
      "            - shape(2, N): Separate - and + values for each bar. First row\n",
      "              contains the lower errors, the second row contains the upper\n",
      "              errors.\n",
      "            - *None*: No errorbar. (default)\n",
      "        \n",
      "            See :doc:`/gallery/statistics/errorbar_features`\n",
      "            for an example on the usage of ``xerr`` and ``yerr``.\n",
      "        \n",
      "        ecolor : color or list of color, default: 'black'\n",
      "            The line color of the errorbars.\n",
      "        \n",
      "        capsize : float, default: :rc:`errorbar.capsize`\n",
      "           The length of the error bar caps in points.\n",
      "        \n",
      "        error_kw : dict, optional\n",
      "            Dictionary of kwargs to be passed to the `~.Axes.errorbar`\n",
      "            method. Values of *ecolor* or *capsize* defined here take\n",
      "            precedence over the independent kwargs.\n",
      "        \n",
      "        log : bool, default: False\n",
      "            If ``True``, set the x-axis to be log scale.\n",
      "        \n",
      "        **kwargs : `.Rectangle` properties\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: unknown\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color: color\n",
      "            contains: unknown\n",
      "            edgecolor or ec: color or None or 'auto'\n",
      "            facecolor or fc: color or None\n",
      "            figure: `.Figure`\n",
      "            fill: bool\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float or None\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        bar : Plot a vertical bar plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Stacked bars can be achieved by passing individual *left* values per\n",
      "        bar. See\n",
      "        :doc:`/gallery/lines_bars_and_markers/horizontal_barchart_distribution`\n",
      "        .\n",
      "    \n",
      "    bone()\n",
      "        Set the colormap to 'bone'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    box(on=None)\n",
      "        Turn the axes box on or off on the current axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        on : bool or None\n",
      "            The new `~matplotlib.axes.Axes` box state. If ``None``, toggle\n",
      "            the state.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :meth:`matplotlib.axes.Axes.set_frame_on`\n",
      "        :meth:`matplotlib.axes.Axes.get_frame_on`\n",
      "    \n",
      "    boxplot(x, notch=None, sym=None, vert=None, whis=None, positions=None, widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None, meanline=None, showmeans=None, showcaps=None, showbox=None, showfliers=None, boxprops=None, labels=None, flierprops=None, medianprops=None, meanprops=None, capprops=None, whiskerprops=None, manage_ticks=True, autorange=False, zorder=None, *, data=None)\n",
      "        Make a box and whisker plot.\n",
      "        \n",
      "        Make a box and whisker plot for each column of *x* or each\n",
      "        vector in sequence *x*.  The box extends from the lower to\n",
      "        upper quartile values of the data, with a line at the median.\n",
      "        The whiskers extend from the box to show the range of the\n",
      "        data.  Flier points are those past the end of the whiskers.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : Array or a sequence of vectors.\n",
      "            The input data.\n",
      "        \n",
      "        notch : bool, default: False\n",
      "            Whether to draw a notched box plot (`True`), or a rectangular box\n",
      "            plot (`False`).  The notches represent the confidence interval (CI)\n",
      "            around the median.  The documentation for *bootstrap* describes how\n",
      "            the locations of the notches are computed by default, but their\n",
      "            locations may also be overridden by setting the *conf_intervals*\n",
      "            parameter.\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "                In cases where the values of the CI are less than the\n",
      "                lower quartile or greater than the upper quartile, the\n",
      "                notches will extend beyond the box, giving it a\n",
      "                distinctive \"flipped\" appearance. This is expected\n",
      "                behavior and consistent with other statistical\n",
      "                visualization packages.\n",
      "        \n",
      "        sym : str, optional\n",
      "            The default symbol for flier points.  An empty string ('') hides\n",
      "            the fliers.  If `None`, then the fliers default to 'b+'.  More\n",
      "            control is provided by the *flierprops* parameter.\n",
      "        \n",
      "        vert : bool, default: True\n",
      "            If `True`, draws vertical boxes.\n",
      "            If `False`, draw horizontal boxes.\n",
      "        \n",
      "        whis : float or (float, float), default: 1.5\n",
      "            The position of the whiskers.\n",
      "        \n",
      "            If a float, the lower whisker is at the lowest datum above\n",
      "            ``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum\n",
      "            below ``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and\n",
      "            third quartiles.  The default value of ``whis = 1.5`` corresponds\n",
      "            to Tukey's original definition of boxplots.\n",
      "        \n",
      "            If a pair of floats, they indicate the percentiles at which to\n",
      "            draw the whiskers (e.g., (5, 95)).  In particular, setting this to\n",
      "            (0, 100) results in whiskers covering the whole range of the data.\n",
      "        \n",
      "            In the edge case where ``Q1 == Q3``, *whis* is automatically set\n",
      "            to (0, 100) (cover the whole range of the data) if *autorange* is\n",
      "            True.\n",
      "        \n",
      "            Beyond the whiskers, data are considered outliers and are plotted\n",
      "            as individual points.\n",
      "        \n",
      "        bootstrap : int, optional\n",
      "            Specifies whether to bootstrap the confidence intervals\n",
      "            around the median for notched boxplots. If *bootstrap* is\n",
      "            None, no bootstrapping is performed, and notches are\n",
      "            calculated using a Gaussian-based asymptotic approximation\n",
      "            (see McGill, R., Tukey, J.W., and Larsen, W.A., 1978, and\n",
      "            Kendall and Stuart, 1967). Otherwise, bootstrap specifies\n",
      "            the number of times to bootstrap the median to determine its\n",
      "            95% confidence intervals. Values between 1000 and 10000 are\n",
      "            recommended.\n",
      "        \n",
      "        usermedians : 1D array-like, optional\n",
      "            A 1D array-like of length ``len(x)``.  Each entry that is not\n",
      "            `None` forces the value of the median for the corresponding\n",
      "            dataset.  For entries that are `None`, the medians are computed\n",
      "            by Matplotlib as normal.\n",
      "        \n",
      "        conf_intervals : array-like, optional\n",
      "            A 2D array-like of shape ``(len(x), 2)``.  Each entry that is not\n",
      "            None forces the location of the corresponding notch (which is\n",
      "            only drawn if *notch* is `True`).  For entries that are `None`,\n",
      "            the notches are computed by the method specified by the other\n",
      "            parameters (e.g., *bootstrap*).\n",
      "        \n",
      "        positions : array-like, optional\n",
      "            The positions of the boxes. The ticks and limits are\n",
      "            automatically set to match the positions. Defaults to\n",
      "            ``range(1, N+1)`` where N is the number of boxes to be drawn.\n",
      "        \n",
      "        widths : float or array-like\n",
      "            The widths of the boxes.  The default is 0.5, or ``0.15*(distance\n",
      "            between extreme positions)``, if that is smaller.\n",
      "        \n",
      "        patch_artist : bool, default: False\n",
      "            If `False` produces boxes with the Line2D artist. Otherwise,\n",
      "            boxes and drawn with Patch artists.\n",
      "        \n",
      "        labels : sequence, optional\n",
      "            Labels for each dataset (one per dataset).\n",
      "        \n",
      "        manage_ticks : bool, default: True\n",
      "            If True, the tick locations and labels will be adjusted to match\n",
      "            the boxplot positions.\n",
      "        \n",
      "        autorange : bool, default: False\n",
      "            When `True` and the data are distributed such that the 25th and\n",
      "            75th percentiles are equal, *whis* is set to (0, 100) such\n",
      "            that the whisker ends are at the minimum and maximum of the data.\n",
      "        \n",
      "        meanline : bool, default: False\n",
      "            If `True` (and *showmeans* is `True`), will try to render the\n",
      "            mean as a line spanning the full width of the box according to\n",
      "            *meanprops* (see below).  Not recommended if *shownotches* is also\n",
      "            True.  Otherwise, means will be shown as points.\n",
      "        \n",
      "        zorder : float, default: ``Line2D.zorder = 2``\n",
      "            The zorder of the boxplot.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        dict\n",
      "          A dictionary mapping each component of the boxplot to a list\n",
      "          of the `.Line2D` instances created. That dictionary has the\n",
      "          following keys (assuming vertical boxplots):\n",
      "        \n",
      "          - ``boxes``: the main body of the boxplot showing the\n",
      "            quartiles and the median's confidence intervals if\n",
      "            enabled.\n",
      "        \n",
      "          - ``medians``: horizontal lines at the median of each box.\n",
      "        \n",
      "          - ``whiskers``: the vertical lines extending to the most\n",
      "            extreme, non-outlier data points.\n",
      "        \n",
      "          - ``caps``: the horizontal lines at the ends of the\n",
      "            whiskers.\n",
      "        \n",
      "          - ``fliers``: points representing data that extend beyond\n",
      "            the whiskers (fliers).\n",
      "        \n",
      "          - ``means``: points or lines representing the means.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        showcaps : bool, default: True\n",
      "            Show the caps on the ends of whiskers.\n",
      "        showbox : bool, default: True\n",
      "            Show the central box.\n",
      "        showfliers : bool, default: True\n",
      "            Show the outliers beyond the caps.\n",
      "        showmeans : bool, default: False\n",
      "            Show the arithmetic means.\n",
      "        capprops : dict, default: None\n",
      "            The style of the caps.\n",
      "        boxprops : dict, default: None\n",
      "            The style of the box.\n",
      "        whiskerprops : dict, default: None\n",
      "            The style of the whiskers.\n",
      "        flierprops : dict, default: None\n",
      "            The style of the fliers.\n",
      "        medianprops : dict, default: None\n",
      "            The style of the median.\n",
      "        meanprops : dict, default: None\n",
      "            The style of the mean.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Box plots provide insight into distribution properties of the data.\n",
      "        However, they can be challenging to interpret for the unfamiliar\n",
      "        reader. The figure below illustrates the different visual features of\n",
      "        a box plot.\n",
      "        \n",
      "        .. image:: /_static/boxplot_explanation.png\n",
      "           :alt: Illustration of box plot features\n",
      "           :scale: 50 %\n",
      "        \n",
      "        The whiskers mark the range of the non-outlier data. The most common\n",
      "        definition of non-outlier is ``[Q1 - 1.5xIQR, Q3 + 1.5xIQR]``, which\n",
      "        is also the default in this function. Other whisker meanings can be\n",
      "        applied via the *whis* parameter.\n",
      "        \n",
      "        See `Box plot <https://en.wikipedia.org/wiki/Box_plot>`_ on Wikipedia\n",
      "        for further information.\n",
      "        \n",
      "        Violin plots (`~.Axes.violinplot`) add even more detail about the\n",
      "        statistical distribution by plotting the kernel density estimation\n",
      "        (KDE) as an estimation of the probability density function.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    broken_barh(xranges, yrange, *, data=None, **kwargs)\n",
      "        Plot a horizontal sequence of rectangles.\n",
      "        \n",
      "        A rectangle is drawn for each element of *xranges*. All rectangles\n",
      "        have the same vertical position and size defined by *yrange*.\n",
      "        \n",
      "        This is a convenience function for instantiating a\n",
      "        `.BrokenBarHCollection`, adding it to the Axes and autoscaling the\n",
      "        view.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xranges : sequence of tuples (*xmin*, *xwidth*)\n",
      "            The x-positions and extends of the rectangles. For each tuple\n",
      "            (*xmin*, *xwidth*) a rectangle is drawn from *xmin* to *xmin* +\n",
      "            *xwidth*.\n",
      "        yrange : (*ymin*, *yheight*)\n",
      "            The y-position and extend for all the rectangles.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~.collections.BrokenBarHCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `.BrokenBarHCollection` properties\n",
      "        \n",
      "            Each *kwarg* can be either a single argument applying to all\n",
      "            rectangles, e.g.::\n",
      "        \n",
      "                facecolors='black'\n",
      "        \n",
      "            or a sequence of arguments over which is cycled, e.g.::\n",
      "        \n",
      "                facecolors=('black', 'blue')\n",
      "        \n",
      "            would create interleaving black and blue rectangles.\n",
      "        \n",
      "            Supported keywords:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    cla()\n",
      "        Clear the current axes.\n",
      "    \n",
      "    clabel(CS, levels=None, **kwargs)\n",
      "        Label a contour plot.\n",
      "        \n",
      "        Adds labels to line contours in given `.ContourSet`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        CS : `~.ContourSet` instance\n",
      "            Line contours to label.\n",
      "        \n",
      "        levels : array-like, optional\n",
      "            A list of level values, that should be labeled. The list must be\n",
      "            a subset of ``CS.levels``. If not given, all levels are labeled.\n",
      "        \n",
      "        **kwargs\n",
      "            All other parameters are documented in `~.ContourLabeler.clabel`.\n",
      "    \n",
      "    clf()\n",
      "        Clear the current figure.\n",
      "    \n",
      "    clim(vmin=None, vmax=None)\n",
      "        Set the color limits of the current image.\n",
      "        \n",
      "        If either *vmin* or *vmax* is None, the image min/max respectively\n",
      "        will be used for color scaling.\n",
      "        \n",
      "        If you want to set the clim of multiple images, use\n",
      "        `~.ScalarMappable.set_clim` on every image, for example::\n",
      "        \n",
      "          for im in gca().get_images():\n",
      "              im.set_clim(0, 0.5)\n",
      "    \n",
      "    close(fig=None)\n",
      "        Close a figure window.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fig : None or int or str or `.Figure`\n",
      "            The figure to close. There are a number of ways to specify this:\n",
      "        \n",
      "            - *None*: the current figure\n",
      "            - `.Figure`: the given `.Figure` instance\n",
      "            - ``int``: a figure number\n",
      "            - ``str``: a figure name\n",
      "            - 'all': all figures\n",
      "    \n",
      "    cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0x0000018044793AF0>, window=<function window_hanning at 0x0000018044793790>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, *, data=None, **kwargs)\n",
      "        Plot the coherence between *x* and *y*.\n",
      "        \n",
      "        Plot the coherence between *x* and *y*.  Coherence is the\n",
      "        normalized cross spectral density:\n",
      "        \n",
      "        .. math::\n",
      "        \n",
      "          C_{xy} = \\frac{|P_{xy}|^2}{P_{xx}P_{yy}}\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  This can be different from *NFFT*, which specifies the number\n",
      "            of data points used.  While not increasing the actual resolution of the\n",
      "            spectrum (the minimum distance between resolvable peaks), this can give\n",
      "            more points in the plot, allowing for more detail. This corresponds to\n",
      "            the *n* parameter in the call to fft(). The default is None, which sets\n",
      "            *pad_to* equal to *NFFT*\n",
      "        \n",
      "        NFFT : int, default: 256\n",
      "            The number of data points used in each block for the FFT.  A power 2 is\n",
      "            most efficient.  This should *NOT* be used to get zero padding, or the\n",
      "            scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      "            The function applied to each segment before fft-ing, designed to remove\n",
      "            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      "            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`\n",
      "            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      "            but you can use a custom function as well.  You can also use a string to\n",
      "            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      "            `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      "        \n",
      "        scale_by_freq : bool, default: True\n",
      "            Whether the resulting density values should be scaled by the scaling\n",
      "            frequency, which gives density in units of Hz^-1.  This allows for\n",
      "            integration over the returned frequency values.  The default is True for\n",
      "            MATLAB compatibility.\n",
      "        \n",
      "        noverlap : int, default: 0 (no overlap)\n",
      "            The number of points of overlap between blocks.\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Cxy : 1-D array\n",
      "            The coherence vector.\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies for the elements in *Cxy*.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      "        John Wiley & Sons (1986)\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    colorbar(mappable=None, cax=None, ax=None, **kw)\n",
      "        Add a colorbar to a plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mappable\n",
      "            The `matplotlib.cm.ScalarMappable` (i.e., `~matplotlib.image.AxesImage`,\n",
      "            `~matplotlib.contour.ContourSet`, etc.) described by this colorbar.\n",
      "            This argument is mandatory for the `.Figure.colorbar` method but optional\n",
      "            for the `.pyplot.colorbar` function, which sets the default to the current\n",
      "            image.\n",
      "        \n",
      "            Note that one can create a `.ScalarMappable` \"on-the-fly\" to generate\n",
      "            colorbars not attached to a previously drawn artist, e.g. ::\n",
      "        \n",
      "                fig.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax)\n",
      "        \n",
      "        cax : `~matplotlib.axes.Axes`, optional\n",
      "            Axes into which the colorbar will be drawn.\n",
      "        \n",
      "        ax : `~matplotlib.axes.Axes`, list of Axes, optional\n",
      "            One or more parent axes from which space for a new colorbar axes will be\n",
      "            stolen, if *cax* is None.  This has no effect if *cax* is set.\n",
      "        \n",
      "        use_gridspec : bool, optional\n",
      "            If *cax* is ``None``, a new *cax* is created as an instance of Axes.  If\n",
      "            *ax* is an instance of Subplot and *use_gridspec* is ``True``, *cax* is\n",
      "            created as an instance of Subplot using the :mod:`~.gridspec` module.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        colorbar : `~matplotlib.colorbar.Colorbar`\n",
      "            See also its base class, `~matplotlib.colorbar.ColorbarBase`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Additional keyword arguments are of two kinds:\n",
      "        \n",
      "          axes properties:\n",
      "        \n",
      "            location : None or {'left', 'right', 'top', 'bottom'}\n",
      "                The location, relative to the parent axes, where the colorbar axes\n",
      "                is created.  It also determines the *orientation* of the colorbar\n",
      "                (colorbars on the left and right are vertical, colorbars at the top\n",
      "                and bottom are horizontal).  If None, the location will come from the\n",
      "                *orientation* if it is set (vertical colorbars on the right, horizontal\n",
      "                ones at the bottom), or default to 'right' if *orientation* is unset.\n",
      "            orientation : None or {'vertical', 'horizontal'}\n",
      "                The orientation of the colorbar.  It is preferable to set the *location*\n",
      "                of the colorbar, as that also determines the *orientation*; passing\n",
      "                incompatible values for *location* and *orientation* raises an exception.\n",
      "            fraction : float, default: 0.15\n",
      "                Fraction of original axes to use for colorbar.\n",
      "            shrink : float, default: 1.0\n",
      "                Fraction by which to multiply the size of the colorbar.\n",
      "            aspect : float, default: 20\n",
      "                Ratio of long to short dimensions.\n",
      "        \n",
      "        \n",
      "            pad : float, default: 0.05 if vertical, 0.15 if horizontal\n",
      "                Fraction of original axes between colorbar and new image axes.\n",
      "            anchor : (float, float), optional\n",
      "                The anchor point of the colorbar axes.\n",
      "                Defaults to (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal.\n",
      "            panchor : (float, float), or *False*, optional\n",
      "                The anchor point of the colorbar parent axes. If *False*, the parent\n",
      "                axes' anchor will be unchanged.\n",
      "                Defaults to (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal.\n",
      "        \n",
      "          colorbar properties:\n",
      "        \n",
      "        \n",
      "            ============  ====================================================\n",
      "            Property      Description\n",
      "            ============  ====================================================\n",
      "            *extend*      {'neither', 'both', 'min', 'max'}\n",
      "                          If not 'neither', make pointed end(s) for out-of-\n",
      "                          range values.  These are set for a given colormap\n",
      "                          using the colormap set_under and set_over methods.\n",
      "            *extendfrac*  {*None*, 'auto', length, lengths}\n",
      "                          If set to *None*, both the minimum and maximum\n",
      "                          triangular colorbar extensions with have a length of\n",
      "                          5% of the interior colorbar length (this is the\n",
      "                          default setting). If set to 'auto', makes the\n",
      "                          triangular colorbar extensions the same lengths as\n",
      "                          the interior boxes (when *spacing* is set to\n",
      "                          'uniform') or the same lengths as the respective\n",
      "                          adjacent interior boxes (when *spacing* is set to\n",
      "                          'proportional'). If a scalar, indicates the length\n",
      "                          of both the minimum and maximum triangular colorbar\n",
      "                          extensions as a fraction of the interior colorbar\n",
      "                          length. A two-element sequence of fractions may also\n",
      "                          be given, indicating the lengths of the minimum and\n",
      "                          maximum colorbar extensions respectively as a\n",
      "                          fraction of the interior colorbar length.\n",
      "            *extendrect*  bool\n",
      "                          If *False* the minimum and maximum colorbar extensions\n",
      "                          will be triangular (the default). If *True* the\n",
      "                          extensions will be rectangular.\n",
      "            *spacing*     {'uniform', 'proportional'}\n",
      "                          Uniform spacing gives each discrete color the same\n",
      "                          space; proportional makes the space proportional to\n",
      "                          the data interval.\n",
      "            *ticks*       *None* or list of ticks or Locator\n",
      "                          If None, ticks are determined automatically from the\n",
      "                          input.\n",
      "            *format*      None or str or Formatter\n",
      "                          If None, `~.ticker.ScalarFormatter` is used.\n",
      "                          If a format string is given, e.g., '%.3f', that is used.\n",
      "                          An alternative `~.ticker.Formatter` may be given instead.\n",
      "            *drawedges*   bool\n",
      "                          Whether to draw lines at color boundaries.\n",
      "            *label*       str\n",
      "                          The label on the colorbar's long axis.\n",
      "            ============  ====================================================\n",
      "        \n",
      "            The following will probably be useful only in the context of\n",
      "            indexed colors (that is, when the mappable has norm=NoNorm()),\n",
      "            or other unusual circumstances.\n",
      "        \n",
      "            ============   ===================================================\n",
      "            Property       Description\n",
      "            ============   ===================================================\n",
      "            *boundaries*   None or a sequence\n",
      "            *values*       None or a sequence which must be of length 1 less\n",
      "                           than the sequence of *boundaries*. For each region\n",
      "                           delimited by adjacent entries in *boundaries*, the\n",
      "                           colormapped to the corresponding value in values\n",
      "                           will be used.\n",
      "            ============   ===================================================\n",
      "        \n",
      "        \n",
      "        \n",
      "        If *mappable* is a `~.contour.ContourSet`, its *extend* kwarg is included\n",
      "        automatically.\n",
      "        \n",
      "        The *shrink* kwarg provides a simple way to scale the colorbar with respect\n",
      "        to the axes. Note that if *cax* is specified, it determines the size of the\n",
      "        colorbar and *shrink* and *aspect* kwargs are ignored.\n",
      "        \n",
      "        For more precise control, you can manually specify the positions of\n",
      "        the axes objects in which the mappable and the colorbar are drawn.  In\n",
      "        this case, do not use any of the axes properties kwargs.\n",
      "        \n",
      "        It is known that some vector graphics viewers (svg and pdf) renders white gaps\n",
      "        between segments of the colorbar.  This is due to bugs in the viewers, not\n",
      "        Matplotlib.  As a workaround, the colorbar can be rendered with overlapping\n",
      "        segments::\n",
      "        \n",
      "            cbar = colorbar()\n",
      "            cbar.solids.set_edgecolor(\"face\")\n",
      "            draw()\n",
      "        \n",
      "        However this has negative consequences in other circumstances, e.g. with\n",
      "        semi-transparent images (alpha < 1) and colorbar extensions; therefore, this\n",
      "        workaround is not used by default (see issue #1188).\n",
      "    \n",
      "    colormaps()\n",
      "        Matplotlib provides a number of colormaps, and others can be added using\n",
      "        :func:`~matplotlib.cm.register_cmap`.  This function documents the built-in\n",
      "        colormaps, and will also return a list of all registered colormaps if\n",
      "        called.\n",
      "        \n",
      "        You can set the colormap for an image, pcolor, scatter, etc,\n",
      "        using a keyword argument::\n",
      "        \n",
      "          imshow(X, cmap=cm.hot)\n",
      "        \n",
      "        or using the :func:`set_cmap` function::\n",
      "        \n",
      "          imshow(X)\n",
      "          pyplot.set_cmap('hot')\n",
      "          pyplot.set_cmap('jet')\n",
      "        \n",
      "        In interactive mode, :func:`set_cmap` will update the colormap post-hoc,\n",
      "        allowing you to see which one works best for your data.\n",
      "        \n",
      "        All built-in colormaps can be reversed by appending ``_r``: For instance,\n",
      "        ``gray_r`` is the reverse of ``gray``.\n",
      "        \n",
      "        There are several common color schemes used in visualization:\n",
      "        \n",
      "        Sequential schemes\n",
      "          for unipolar data that progresses from low to high\n",
      "        Diverging schemes\n",
      "          for bipolar data that emphasizes positive or negative deviations from a\n",
      "          central value\n",
      "        Cyclic schemes\n",
      "          for plotting values that wrap around at the endpoints, such as phase\n",
      "          angle, wind direction, or time of day\n",
      "        Qualitative schemes\n",
      "          for nominal data that has no inherent ordering, where color is used\n",
      "          only to distinguish categories\n",
      "        \n",
      "        Matplotlib ships with 4 perceptually uniform colormaps which are\n",
      "        the recommended colormaps for sequential data:\n",
      "        \n",
      "          =========   ===================================================\n",
      "          Colormap    Description\n",
      "          =========   ===================================================\n",
      "          inferno     perceptually uniform shades of black-red-yellow\n",
      "          magma       perceptually uniform shades of black-red-white\n",
      "          plasma      perceptually uniform shades of blue-red-yellow\n",
      "          viridis     perceptually uniform shades of blue-green-yellow\n",
      "          =========   ===================================================\n",
      "        \n",
      "        The following colormaps are based on the `ColorBrewer\n",
      "        <https://colorbrewer2.org>`_ color specifications and designs developed by\n",
      "        Cynthia Brewer:\n",
      "        \n",
      "        ColorBrewer Diverging (luminance is highest at the midpoint, and\n",
      "        decreases towards differently-colored endpoints):\n",
      "        \n",
      "          ========  ===================================\n",
      "          Colormap  Description\n",
      "          ========  ===================================\n",
      "          BrBG      brown, white, blue-green\n",
      "          PiYG      pink, white, yellow-green\n",
      "          PRGn      purple, white, green\n",
      "          PuOr      orange, white, purple\n",
      "          RdBu      red, white, blue\n",
      "          RdGy      red, white, gray\n",
      "          RdYlBu    red, yellow, blue\n",
      "          RdYlGn    red, yellow, green\n",
      "          Spectral  red, orange, yellow, green, blue\n",
      "          ========  ===================================\n",
      "        \n",
      "        ColorBrewer Sequential (luminance decreases monotonically):\n",
      "        \n",
      "          ========  ====================================\n",
      "          Colormap  Description\n",
      "          ========  ====================================\n",
      "          Blues     white to dark blue\n",
      "          BuGn      white, light blue, dark green\n",
      "          BuPu      white, light blue, dark purple\n",
      "          GnBu      white, light green, dark blue\n",
      "          Greens    white to dark green\n",
      "          Greys     white to black (not linear)\n",
      "          Oranges   white, orange, dark brown\n",
      "          OrRd      white, orange, dark red\n",
      "          PuBu      white, light purple, dark blue\n",
      "          PuBuGn    white, light purple, dark green\n",
      "          PuRd      white, light purple, dark red\n",
      "          Purples   white to dark purple\n",
      "          RdPu      white, pink, dark purple\n",
      "          Reds      white to dark red\n",
      "          YlGn      light yellow, dark green\n",
      "          YlGnBu    light yellow, light green, dark blue\n",
      "          YlOrBr    light yellow, orange, dark brown\n",
      "          YlOrRd    light yellow, orange, dark red\n",
      "          ========  ====================================\n",
      "        \n",
      "        ColorBrewer Qualitative:\n",
      "        \n",
      "        (For plotting nominal data, `.ListedColormap` is used,\n",
      "        not `.LinearSegmentedColormap`.  Different sets of colors are\n",
      "        recommended for different numbers of categories.)\n",
      "        \n",
      "        * Accent\n",
      "        * Dark2\n",
      "        * Paired\n",
      "        * Pastel1\n",
      "        * Pastel2\n",
      "        * Set1\n",
      "        * Set2\n",
      "        * Set3\n",
      "        \n",
      "        A set of colormaps derived from those of the same name provided\n",
      "        with Matlab are also included:\n",
      "        \n",
      "          =========   =======================================================\n",
      "          Colormap    Description\n",
      "          =========   =======================================================\n",
      "          autumn      sequential linearly-increasing shades of red-orange-yellow\n",
      "          bone        sequential increasing black-white colormap with\n",
      "                      a tinge of blue, to emulate X-ray film\n",
      "          cool        linearly-decreasing shades of cyan-magenta\n",
      "          copper      sequential increasing shades of black-copper\n",
      "          flag        repetitive red-white-blue-black pattern (not cyclic at\n",
      "                      endpoints)\n",
      "          gray        sequential linearly-increasing black-to-white\n",
      "                      grayscale\n",
      "          hot         sequential black-red-yellow-white, to emulate blackbody\n",
      "                      radiation from an object at increasing temperatures\n",
      "          jet         a spectral map with dark endpoints, blue-cyan-yellow-red;\n",
      "                      based on a fluid-jet simulation by NCSA [#]_\n",
      "          pink        sequential increasing pastel black-pink-white, meant\n",
      "                      for sepia tone colorization of photographs\n",
      "          prism       repetitive red-yellow-green-blue-purple-...-green pattern\n",
      "                      (not cyclic at endpoints)\n",
      "          spring      linearly-increasing shades of magenta-yellow\n",
      "          summer      sequential linearly-increasing shades of green-yellow\n",
      "          winter      linearly-increasing shades of blue-green\n",
      "          =========   =======================================================\n",
      "        \n",
      "        A set of palettes from the `Yorick scientific visualisation\n",
      "        package <https://dhmunro.github.io/yorick-doc/>`_, an evolution of\n",
      "        the GIST package, both by David H. Munro are included:\n",
      "        \n",
      "          ============  =======================================================\n",
      "          Colormap      Description\n",
      "          ============  =======================================================\n",
      "          gist_earth    mapmaker's colors from dark blue deep ocean to green\n",
      "                        lowlands to brown highlands to white mountains\n",
      "          gist_heat     sequential increasing black-red-orange-white, to emulate\n",
      "                        blackbody radiation from an iron bar as it grows hotter\n",
      "          gist_ncar     pseudo-spectral black-blue-green-yellow-red-purple-white\n",
      "                        colormap from National Center for Atmospheric\n",
      "                        Research [#]_\n",
      "          gist_rainbow  runs through the colors in spectral order from red to\n",
      "                        violet at full saturation (like *hsv* but not cyclic)\n",
      "          gist_stern    \"Stern special\" color table from Interactive Data\n",
      "                        Language software\n",
      "          ============  =======================================================\n",
      "        \n",
      "        A set of cyclic colormaps:\n",
      "        \n",
      "          ================  =================================================\n",
      "          Colormap          Description\n",
      "          ================  =================================================\n",
      "          hsv               red-yellow-green-cyan-blue-magenta-red, formed by\n",
      "                            changing the hue component in the HSV color space\n",
      "          twilight          perceptually uniform shades of\n",
      "                            white-blue-black-red-white\n",
      "          twilight_shifted  perceptually uniform shades of\n",
      "                            black-blue-white-red-black\n",
      "          ================  =================================================\n",
      "        \n",
      "        Other miscellaneous schemes:\n",
      "        \n",
      "          ============= =======================================================\n",
      "          Colormap      Description\n",
      "          ============= =======================================================\n",
      "          afmhot        sequential black-orange-yellow-white blackbody\n",
      "                        spectrum, commonly used in atomic force microscopy\n",
      "          brg           blue-red-green\n",
      "          bwr           diverging blue-white-red\n",
      "          coolwarm      diverging blue-gray-red, meant to avoid issues with 3D\n",
      "                        shading, color blindness, and ordering of colors [#]_\n",
      "          CMRmap        \"Default colormaps on color images often reproduce to\n",
      "                        confusing grayscale images. The proposed colormap\n",
      "                        maintains an aesthetically pleasing color image that\n",
      "                        automatically reproduces to a monotonic grayscale with\n",
      "                        discrete, quantifiable saturation levels.\" [#]_\n",
      "          cubehelix     Unlike most other color schemes cubehelix was designed\n",
      "                        by D.A. Green to be monotonically increasing in terms\n",
      "                        of perceived brightness. Also, when printed on a black\n",
      "                        and white postscript printer, the scheme results in a\n",
      "                        greyscale with monotonically increasing brightness.\n",
      "                        This color scheme is named cubehelix because the (r, g, b)\n",
      "                        values produced can be visualised as a squashed helix\n",
      "                        around the diagonal in the (r, g, b) color cube.\n",
      "          gnuplot       gnuplot's traditional pm3d scheme\n",
      "                        (black-blue-red-yellow)\n",
      "          gnuplot2      sequential color printable as gray\n",
      "                        (black-blue-violet-yellow-white)\n",
      "          ocean         green-blue-white\n",
      "          rainbow       spectral purple-blue-green-yellow-orange-red colormap\n",
      "                        with diverging luminance\n",
      "          seismic       diverging blue-white-red\n",
      "          nipy_spectral black-purple-blue-green-yellow-red-white spectrum,\n",
      "                        originally from the Neuroimaging in Python project\n",
      "          terrain       mapmaker's colors, blue-green-yellow-brown-white,\n",
      "                        originally from IGOR Pro\n",
      "          turbo         Spectral map (purple-blue-green-yellow-orange-red) with\n",
      "                        a bright center and darker endpoints. A smoother\n",
      "                        alternative to jet.\n",
      "          ============= =======================================================\n",
      "        \n",
      "        The following colormaps are redundant and may be removed in future\n",
      "        versions.  It's recommended to use the names in the descriptions\n",
      "        instead, which produce identical output:\n",
      "        \n",
      "          =========  =======================================================\n",
      "          Colormap   Description\n",
      "          =========  =======================================================\n",
      "          gist_gray  identical to *gray*\n",
      "          gist_yarg  identical to *gray_r*\n",
      "          binary     identical to *gray_r*\n",
      "          =========  =======================================================\n",
      "        \n",
      "        .. rubric:: Footnotes\n",
      "        \n",
      "        .. [#] Rainbow colormaps, ``jet`` in particular, are considered a poor\n",
      "          choice for scientific visualization by many researchers: `Rainbow Color\n",
      "          Map (Still) Considered Harmful\n",
      "          <https://ieeexplore.ieee.org/document/4118486/?arnumber=4118486>`_\n",
      "        \n",
      "        .. [#] Resembles \"BkBlAqGrYeOrReViWh200\" from NCAR Command\n",
      "          Language. See `Color Table Gallery\n",
      "          <https://www.ncl.ucar.edu/Document/Graphics/color_table_gallery.shtml>`_\n",
      "        \n",
      "        .. [#] See `Diverging Color Maps for Scientific Visualization\n",
      "          <http://www.kennethmoreland.com/color-maps/>`_ by Kenneth Moreland.\n",
      "        \n",
      "        .. [#] See `A Color Map for Effective Black-and-White Rendering of\n",
      "          Color-Scale Images\n",
      "          <https://www.mathworks.com/matlabcentral/fileexchange/2662-cmrmap-m>`_\n",
      "          by Carey Rappaport\n",
      "    \n",
      "    connect(s, func)\n",
      "        Bind function *func* to event *s*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        s : str\n",
      "            One of the following events ids:\n",
      "        \n",
      "            - 'button_press_event'\n",
      "            - 'button_release_event'\n",
      "            - 'draw_event'\n",
      "            - 'key_press_event'\n",
      "            - 'key_release_event'\n",
      "            - 'motion_notify_event'\n",
      "            - 'pick_event'\n",
      "            - 'resize_event'\n",
      "            - 'scroll_event'\n",
      "            - 'figure_enter_event',\n",
      "            - 'figure_leave_event',\n",
      "            - 'axes_enter_event',\n",
      "            - 'axes_leave_event'\n",
      "            - 'close_event'.\n",
      "        \n",
      "        func : callable\n",
      "            The callback function to be executed, which must have the\n",
      "            signature::\n",
      "        \n",
      "                def func(event: Event) -> Any\n",
      "        \n",
      "            For the location events (button and key press/release), if the\n",
      "            mouse is over the axes, the ``inaxes`` attribute of the event will\n",
      "            be set to the `~matplotlib.axes.Axes` the event occurs is over, and\n",
      "            additionally, the variables ``xdata`` and ``ydata`` attributes will\n",
      "            be set to the mouse location in data coordinates.  See `.KeyEvent`\n",
      "            and `.MouseEvent` for more info.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        cid\n",
      "            A connection id that can be used with\n",
      "            `.FigureCanvasBase.mpl_disconnect`.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            def on_press(event):\n",
      "                print('you pressed', event.button, event.xdata, event.ydata)\n",
      "        \n",
      "            cid = canvas.mpl_connect('button_press_event', on_press)\n",
      "    \n",
      "    contour(*args, data=None, **kwargs)\n",
      "        Plot contour lines.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            contour([X, Y,] Z, [levels], **kwargs)\n",
      "        \n",
      "        `.contour` and `.contourf` draw contour lines and filled contours,\n",
      "        respectively.  Except as noted, function signatures and return values\n",
      "        are the same for both versions.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X, Y : array-like, optional\n",
      "            The coordinates of the values in *Z*.\n",
      "        \n",
      "            *X* and *Y* must both be 2D with the same shape as *Z* (e.g.\n",
      "            created via `numpy.meshgrid`), or they must both be 1-D such\n",
      "            that ``len(X) == M`` is the number of columns in *Z* and\n",
      "            ``len(Y) == N`` is the number of rows in *Z*.\n",
      "        \n",
      "            If not given, they are assumed to be integer indices, i.e.\n",
      "            ``X = range(M)``, ``Y = range(N)``.\n",
      "        \n",
      "        Z : (M, N) array-like\n",
      "            The height values over which the contour is drawn.\n",
      "        \n",
      "        levels : int or array-like, optional\n",
      "            Determines the number and positions of the contour lines / regions.\n",
      "        \n",
      "            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries\n",
      "            to automatically choose no more than *n+1* \"nice\" contour levels\n",
      "            between *vmin* and *vmax*.\n",
      "        \n",
      "            If array-like, draw contour lines at the specified levels.\n",
      "            The values must be in increasing order.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~.contour.QuadContourSet`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        corner_mask : bool, default: :rc:`contour.corner_mask`\n",
      "            Enable/disable corner masking, which only has an effect if *Z* is\n",
      "            a masked array.  If ``False``, any quad touching a masked point is\n",
      "            masked out.  If ``True``, only the triangular corners of quads\n",
      "            nearest those points are always masked out, other triangular\n",
      "            corners comprising three unmasked points are contoured as usual.\n",
      "        \n",
      "        colors : color string or sequence of colors, optional\n",
      "            The colors of the levels, i.e. the lines for `.contour` and the\n",
      "            areas for `.contourf`.\n",
      "        \n",
      "            The sequence is cycled for the levels in ascending order. If the\n",
      "            sequence is shorter than the number of levels, it's repeated.\n",
      "        \n",
      "            As a shortcut, single color strings may be used in place of\n",
      "            one-element lists, i.e. ``'red'`` instead of ``['red']`` to color\n",
      "            all levels with the same color. This shortcut does only work for\n",
      "            color strings, not for other ways of specifying colors.\n",
      "        \n",
      "            By default (value *None*), the colormap specified by *cmap*\n",
      "            will be used.\n",
      "        \n",
      "        alpha : float, default: 1\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      "            A `.Colormap` instance or registered colormap name. The colormap\n",
      "            maps the level values to colors.\n",
      "        \n",
      "            If both *colors* and *cmap* are given, an error is raised.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            If a colormap is used, the `.Normalize` instance scales the level\n",
      "            values to the canonical colormap range [0, 1] for mapping to\n",
      "            colors. If not given, the default linear scaling is used.\n",
      "        \n",
      "        vmin, vmax : float, optional\n",
      "            If not *None*, either or both of these values will be supplied to\n",
      "            the `.Normalize` instance, overriding the default color scaling\n",
      "            based on *levels*.\n",
      "        \n",
      "        origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      "            Determines the orientation and exact position of *Z* by specifying\n",
      "            the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*\n",
      "            are not given.\n",
      "        \n",
      "            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      "            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      "            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left\n",
      "              corner.\n",
      "            - 'image': Use the value from :rc:`image.origin`.\n",
      "        \n",
      "        extent : (x0, x1, y0, y1), optional\n",
      "            If *origin* is not *None*, then *extent* is interpreted as in\n",
      "            `.imshow`: it gives the outer pixel boundaries. In this case, the\n",
      "            position of Z[0, 0] is the center of the pixel, not a corner. If\n",
      "            *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],\n",
      "            and (*x1*, *y1*) is the position of Z[-1, -1].\n",
      "        \n",
      "            This argument is ignored if *X* and *Y* are specified in the call\n",
      "            to contour.\n",
      "        \n",
      "        locator : ticker.Locator subclass, optional\n",
      "            The locator is used to determine the contour levels if they\n",
      "            are not given explicitly via *levels*.\n",
      "            Defaults to `~.ticker.MaxNLocator`.\n",
      "        \n",
      "        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      "            Determines the ``contourf``-coloring of values that are outside the\n",
      "            *levels* range.\n",
      "        \n",
      "            If 'neither', values outside the *levels* range are not colored.\n",
      "            If 'min', 'max' or 'both', color the values below, above or below\n",
      "            and above the *levels* range.\n",
      "        \n",
      "            Values below ``min(levels)`` and above ``max(levels)`` are mapped\n",
      "            to the under/over values of the `.Colormap`. Note that most\n",
      "            colormaps do not have dedicated colors for these by default, so\n",
      "            that the over and under values are the edge values of the colormap.\n",
      "            You may want to set these values explicitly using\n",
      "            `.Colormap.set_under` and `.Colormap.set_over`.\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "                An existing `.QuadContourSet` does not get notified if\n",
      "                properties of its colormap are changed. Therefore, an explicit\n",
      "                call `.QuadContourSet.changed()` is needed after modifying the\n",
      "                colormap. The explicit call can be left out, if a colorbar is\n",
      "                assigned to the `.QuadContourSet` because it internally calls\n",
      "                `.QuadContourSet.changed()`.\n",
      "        \n",
      "            Example::\n",
      "        \n",
      "                x = np.arange(1, 10)\n",
      "                y = x.reshape(-1, 1)\n",
      "                h = x * y\n",
      "        \n",
      "                cs = plt.contourf(h, levels=[10, 30, 50],\n",
      "                    colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')\n",
      "                cs.cmap.set_over('red')\n",
      "                cs.cmap.set_under('blue')\n",
      "                cs.changed()\n",
      "        \n",
      "        xunits, yunits : registered units, optional\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        antialiased : bool, optional\n",
      "            Enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from :rc:`lines.antialiased`.\n",
      "        \n",
      "        nchunk : int >= 0, optional\n",
      "            If 0, no subdivision of the domain.  Specify a positive integer to\n",
      "            divide the domain into subdomains of *nchunk* by *nchunk* quads.\n",
      "            Chunking reduces the maximum length of polygons generated by the\n",
      "            contouring algorithm which reduces the rendering workload passed\n",
      "            on to the backend and also requires slightly less RAM.  It can\n",
      "            however introduce rendering artifacts at chunk boundaries depending\n",
      "            on the backend, the *antialiased* flag and value of *alpha*.\n",
      "        \n",
      "        linewidths : float or array-like, default: :rc:`contour.linewidth`\n",
      "            *Only applies to* `.contour`.\n",
      "        \n",
      "            The line width of the contour lines.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a sequence, the levels in ascending order will be plotted with\n",
      "            the linewidths in the order specified.\n",
      "        \n",
      "            If None, this falls back to :rc:`lines.linewidth`.\n",
      "        \n",
      "        linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      "            *Only applies to* `.contour`.\n",
      "        \n",
      "            If *linestyles* is *None*, the default is 'solid' unless the lines\n",
      "            are monochrome.  In that case, negative contours will take their\n",
      "            linestyle from :rc:`contour.negative_linestyle` setting.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings\n",
      "            specifying a set of linestyles to be used. If this\n",
      "            iterable is shorter than the number of contour levels\n",
      "            it will be repeated as necessary.\n",
      "        \n",
      "        hatches : list[str], optional\n",
      "            *Only applies to* `.contourf`.\n",
      "        \n",
      "            A list of cross hatch patterns to use on the filled areas.\n",
      "            If None, no hatching will be added to the contour.\n",
      "            Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      "            backends only.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        1. `.contourf` differs from the MATLAB version in that it does not draw\n",
      "           the polygon edges. To draw edges, add line contours with calls to\n",
      "           `.contour`.\n",
      "        \n",
      "        2. `.contourf` fills intervals that are closed at the top; that is, for\n",
      "           boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "              z1 < Z <= z2\n",
      "        \n",
      "           except for the lowest interval, which is closed on both sides (i.e.\n",
      "           it includes the lowest value).\n",
      "    \n",
      "    contourf(*args, data=None, **kwargs)\n",
      "        Plot filled contours.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            contourf([X, Y,] Z, [levels], **kwargs)\n",
      "        \n",
      "        `.contour` and `.contourf` draw contour lines and filled contours,\n",
      "        respectively.  Except as noted, function signatures and return values\n",
      "        are the same for both versions.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X, Y : array-like, optional\n",
      "            The coordinates of the values in *Z*.\n",
      "        \n",
      "            *X* and *Y* must both be 2D with the same shape as *Z* (e.g.\n",
      "            created via `numpy.meshgrid`), or they must both be 1-D such\n",
      "            that ``len(X) == M`` is the number of columns in *Z* and\n",
      "            ``len(Y) == N`` is the number of rows in *Z*.\n",
      "        \n",
      "            If not given, they are assumed to be integer indices, i.e.\n",
      "            ``X = range(M)``, ``Y = range(N)``.\n",
      "        \n",
      "        Z : (M, N) array-like\n",
      "            The height values over which the contour is drawn.\n",
      "        \n",
      "        levels : int or array-like, optional\n",
      "            Determines the number and positions of the contour lines / regions.\n",
      "        \n",
      "            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries\n",
      "            to automatically choose no more than *n+1* \"nice\" contour levels\n",
      "            between *vmin* and *vmax*.\n",
      "        \n",
      "            If array-like, draw contour lines at the specified levels.\n",
      "            The values must be in increasing order.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~.contour.QuadContourSet`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        corner_mask : bool, default: :rc:`contour.corner_mask`\n",
      "            Enable/disable corner masking, which only has an effect if *Z* is\n",
      "            a masked array.  If ``False``, any quad touching a masked point is\n",
      "            masked out.  If ``True``, only the triangular corners of quads\n",
      "            nearest those points are always masked out, other triangular\n",
      "            corners comprising three unmasked points are contoured as usual.\n",
      "        \n",
      "        colors : color string or sequence of colors, optional\n",
      "            The colors of the levels, i.e. the lines for `.contour` and the\n",
      "            areas for `.contourf`.\n",
      "        \n",
      "            The sequence is cycled for the levels in ascending order. If the\n",
      "            sequence is shorter than the number of levels, it's repeated.\n",
      "        \n",
      "            As a shortcut, single color strings may be used in place of\n",
      "            one-element lists, i.e. ``'red'`` instead of ``['red']`` to color\n",
      "            all levels with the same color. This shortcut does only work for\n",
      "            color strings, not for other ways of specifying colors.\n",
      "        \n",
      "            By default (value *None*), the colormap specified by *cmap*\n",
      "            will be used.\n",
      "        \n",
      "        alpha : float, default: 1\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      "            A `.Colormap` instance or registered colormap name. The colormap\n",
      "            maps the level values to colors.\n",
      "        \n",
      "            If both *colors* and *cmap* are given, an error is raised.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            If a colormap is used, the `.Normalize` instance scales the level\n",
      "            values to the canonical colormap range [0, 1] for mapping to\n",
      "            colors. If not given, the default linear scaling is used.\n",
      "        \n",
      "        vmin, vmax : float, optional\n",
      "            If not *None*, either or both of these values will be supplied to\n",
      "            the `.Normalize` instance, overriding the default color scaling\n",
      "            based on *levels*.\n",
      "        \n",
      "        origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      "            Determines the orientation and exact position of *Z* by specifying\n",
      "            the position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y*\n",
      "            are not given.\n",
      "        \n",
      "            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      "            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      "            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left\n",
      "              corner.\n",
      "            - 'image': Use the value from :rc:`image.origin`.\n",
      "        \n",
      "        extent : (x0, x1, y0, y1), optional\n",
      "            If *origin* is not *None*, then *extent* is interpreted as in\n",
      "            `.imshow`: it gives the outer pixel boundaries. In this case, the\n",
      "            position of Z[0, 0] is the center of the pixel, not a corner. If\n",
      "            *origin* is *None*, then (*x0*, *y0*) is the position of Z[0, 0],\n",
      "            and (*x1*, *y1*) is the position of Z[-1, -1].\n",
      "        \n",
      "            This argument is ignored if *X* and *Y* are specified in the call\n",
      "            to contour.\n",
      "        \n",
      "        locator : ticker.Locator subclass, optional\n",
      "            The locator is used to determine the contour levels if they\n",
      "            are not given explicitly via *levels*.\n",
      "            Defaults to `~.ticker.MaxNLocator`.\n",
      "        \n",
      "        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      "            Determines the ``contourf``-coloring of values that are outside the\n",
      "            *levels* range.\n",
      "        \n",
      "            If 'neither', values outside the *levels* range are not colored.\n",
      "            If 'min', 'max' or 'both', color the values below, above or below\n",
      "            and above the *levels* range.\n",
      "        \n",
      "            Values below ``min(levels)`` and above ``max(levels)`` are mapped\n",
      "            to the under/over values of the `.Colormap`. Note that most\n",
      "            colormaps do not have dedicated colors for these by default, so\n",
      "            that the over and under values are the edge values of the colormap.\n",
      "            You may want to set these values explicitly using\n",
      "            `.Colormap.set_under` and `.Colormap.set_over`.\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "                An existing `.QuadContourSet` does not get notified if\n",
      "                properties of its colormap are changed. Therefore, an explicit\n",
      "                call `.QuadContourSet.changed()` is needed after modifying the\n",
      "                colormap. The explicit call can be left out, if a colorbar is\n",
      "                assigned to the `.QuadContourSet` because it internally calls\n",
      "                `.QuadContourSet.changed()`.\n",
      "        \n",
      "            Example::\n",
      "        \n",
      "                x = np.arange(1, 10)\n",
      "                y = x.reshape(-1, 1)\n",
      "                h = x * y\n",
      "        \n",
      "                cs = plt.contourf(h, levels=[10, 30, 50],\n",
      "                    colors=['#808080', '#A0A0A0', '#C0C0C0'], extend='both')\n",
      "                cs.cmap.set_over('red')\n",
      "                cs.cmap.set_under('blue')\n",
      "                cs.changed()\n",
      "        \n",
      "        xunits, yunits : registered units, optional\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        antialiased : bool, optional\n",
      "            Enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from :rc:`lines.antialiased`.\n",
      "        \n",
      "        nchunk : int >= 0, optional\n",
      "            If 0, no subdivision of the domain.  Specify a positive integer to\n",
      "            divide the domain into subdomains of *nchunk* by *nchunk* quads.\n",
      "            Chunking reduces the maximum length of polygons generated by the\n",
      "            contouring algorithm which reduces the rendering workload passed\n",
      "            on to the backend and also requires slightly less RAM.  It can\n",
      "            however introduce rendering artifacts at chunk boundaries depending\n",
      "            on the backend, the *antialiased* flag and value of *alpha*.\n",
      "        \n",
      "        linewidths : float or array-like, default: :rc:`contour.linewidth`\n",
      "            *Only applies to* `.contour`.\n",
      "        \n",
      "            The line width of the contour lines.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a sequence, the levels in ascending order will be plotted with\n",
      "            the linewidths in the order specified.\n",
      "        \n",
      "            If None, this falls back to :rc:`lines.linewidth`.\n",
      "        \n",
      "        linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      "            *Only applies to* `.contour`.\n",
      "        \n",
      "            If *linestyles* is *None*, the default is 'solid' unless the lines\n",
      "            are monochrome.  In that case, negative contours will take their\n",
      "            linestyle from :rc:`contour.negative_linestyle` setting.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings\n",
      "            specifying a set of linestyles to be used. If this\n",
      "            iterable is shorter than the number of contour levels\n",
      "            it will be repeated as necessary.\n",
      "        \n",
      "        hatches : list[str], optional\n",
      "            *Only applies to* `.contourf`.\n",
      "        \n",
      "            A list of cross hatch patterns to use on the filled areas.\n",
      "            If None, no hatching will be added to the contour.\n",
      "            Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      "            backends only.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        1. `.contourf` differs from the MATLAB version in that it does not draw\n",
      "           the polygon edges. To draw edges, add line contours with calls to\n",
      "           `.contour`.\n",
      "        \n",
      "        2. `.contourf` fills intervals that are closed at the top; that is, for\n",
      "           boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "              z1 < Z <= z2\n",
      "        \n",
      "           except for the lowest interval, which is closed on both sides (i.e.\n",
      "           it includes the lowest value).\n",
      "    \n",
      "    cool()\n",
      "        Set the colormap to 'cool'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    copper()\n",
      "        Set the colormap to 'copper'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    csd(x, y, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, *, data=None, **kwargs)\n",
      "        Plot the cross-spectral density.\n",
      "        \n",
      "        The cross spectral density :math:`P_{xy}` by Welch's average\n",
      "        periodogram method.  The vectors *x* and *y* are divided into\n",
      "        *NFFT* length segments.  Each segment is detrended by function\n",
      "        *detrend* and windowed by function *window*.  *noverlap* gives\n",
      "        the length of the overlap between segments.  The product of\n",
      "        the direct FFTs of *x* and *y* are averaged over each segment\n",
      "        to compute :math:`P_{xy}`, with a scaling to correct for power\n",
      "        loss due to windowing.\n",
      "        \n",
      "        If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero\n",
      "        padded to *NFFT*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : 1-D arrays or sequences\n",
      "            Arrays or sequences containing the data.\n",
      "        \n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  This can be different from *NFFT*, which specifies the number\n",
      "            of data points used.  While not increasing the actual resolution of the\n",
      "            spectrum (the minimum distance between resolvable peaks), this can give\n",
      "            more points in the plot, allowing for more detail. This corresponds to\n",
      "            the *n* parameter in the call to fft(). The default is None, which sets\n",
      "            *pad_to* equal to *NFFT*\n",
      "        \n",
      "        NFFT : int, default: 256\n",
      "            The number of data points used in each block for the FFT.  A power 2 is\n",
      "            most efficient.  This should *NOT* be used to get zero padding, or the\n",
      "            scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      "            The function applied to each segment before fft-ing, designed to remove\n",
      "            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      "            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`\n",
      "            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      "            but you can use a custom function as well.  You can also use a string to\n",
      "            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      "            `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      "        \n",
      "        scale_by_freq : bool, default: True\n",
      "            Whether the resulting density values should be scaled by the scaling\n",
      "            frequency, which gives density in units of Hz^-1.  This allows for\n",
      "            integration over the returned frequency values.  The default is True for\n",
      "            MATLAB compatibility.\n",
      "        \n",
      "        noverlap : int, default: 0 (no overlap)\n",
      "            The number of points of overlap between segments.\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        return_line : bool, default: False\n",
      "            Whether to include the line object plotted in the returned values.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Pxy : 1-D array\n",
      "            The values for the cross spectrum :math:`P_{xy}` before scaling\n",
      "            (complex valued).\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *Pxy*.\n",
      "        \n",
      "        line : `~matplotlib.lines.Line2D`\n",
      "            The line created by this function.\n",
      "            Only returned if *return_line* is True.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        psd : is equivalent to setting ``y = x``.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For plotting, the power is plotted as\n",
      "        :math:`10 \\log_{10}(P_{xy})` for decibels, though :math:`P_{xy}` itself\n",
      "        is returned.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      "        John Wiley & Sons (1986)\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    delaxes(ax=None)\n",
      "        Remove an `~.axes.Axes` (defaulting to the current axes) from its figure.\n",
      "    \n",
      "    disconnect(cid)\n",
      "        Disconnect the callback with id *cid*.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            cid = canvas.mpl_connect('button_press_event', on_press)\n",
      "            # ... later\n",
      "            canvas.mpl_disconnect(cid)\n",
      "    \n",
      "    draw()\n",
      "        Redraw the current figure.\n",
      "        \n",
      "        This is used to update a figure that has been altered, but not\n",
      "        automatically re-drawn.  If interactive mode is on (via `.ion()`), this\n",
      "        should be only rarely needed, but there may be ways to modify the state of\n",
      "        a figure without marking it as \"stale\".  Please report these cases as bugs.\n",
      "        \n",
      "        This is equivalent to calling ``fig.canvas.draw_idle()``, where ``fig`` is\n",
      "        the current figure.\n",
      "    \n",
      "    errorbar(x, y, yerr=None, xerr=None, fmt='', ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, *, data=None, **kwargs)\n",
      "        Plot y versus x as lines and/or markers with attached errorbars.\n",
      "        \n",
      "        *x*, *y* define the data locations, *xerr*, *yerr* define the errorbar\n",
      "        sizes. By default, this draws the data markers/lines as well the\n",
      "        errorbars. Use fmt='none' to draw errorbars without any data markers.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : float or array-like\n",
      "            The data positions.\n",
      "        \n",
      "        xerr, yerr : float or array-like, shape(N,) or shape(2, N), optional\n",
      "            The errorbar sizes:\n",
      "        \n",
      "            - scalar: Symmetric +/- values for all data points.\n",
      "            - shape(N,): Symmetric +/-values for each data point.\n",
      "            - shape(2, N): Separate - and + values for each bar. First row\n",
      "              contains the lower errors, the second row contains the upper\n",
      "              errors.\n",
      "            - *None*: No errorbar.\n",
      "        \n",
      "            Note that all error arrays should have *positive* values.\n",
      "        \n",
      "            See :doc:`/gallery/statistics/errorbar_features`\n",
      "            for an example on the usage of ``xerr`` and ``yerr``.\n",
      "        \n",
      "        fmt : str, default: ''\n",
      "            The format for the data points / data lines. See `.plot` for\n",
      "            details.\n",
      "        \n",
      "            Use 'none' (case insensitive) to plot errorbars without any data\n",
      "            markers.\n",
      "        \n",
      "        ecolor : color, default: None\n",
      "            The color of the errorbar lines.  If None, use the color of the\n",
      "            line connecting the markers.\n",
      "        \n",
      "        elinewidth : float, default: None\n",
      "            The linewidth of the errorbar lines. If None, the linewidth of\n",
      "            the current style is used.\n",
      "        \n",
      "        capsize : float, default: :rc:`errorbar.capsize`\n",
      "            The length of the error bar caps in points.\n",
      "        \n",
      "        capthick : float, default: None\n",
      "            An alias to the keyword argument *markeredgewidth* (a.k.a. *mew*).\n",
      "            This setting is a more sensible name for the property that\n",
      "            controls the thickness of the error bar cap in points. For\n",
      "            backwards compatibility, if *mew* or *markeredgewidth* are given,\n",
      "            then they will over-ride *capthick*. This may change in future\n",
      "            releases.\n",
      "        \n",
      "        barsabove : bool, default: False\n",
      "            If True, will plot the errorbars above the plot\n",
      "            symbols. Default is below.\n",
      "        \n",
      "        lolims, uplims, xlolims, xuplims : bool, default: False\n",
      "            These arguments can be used to indicate that a value gives only\n",
      "            upper/lower limits.  In that case a caret symbol is used to\n",
      "            indicate this. *lims*-arguments may be scalars, or array-likes of\n",
      "            the same length as *xerr* and *yerr*.  To use limits with inverted\n",
      "            axes, `~.Axes.set_xlim` or `~.Axes.set_ylim` must be called before\n",
      "            :meth:`errorbar`.  Note the tricky parameter names: setting e.g.\n",
      "            *lolims* to True means that the y-value is a *lower* limit of the\n",
      "            True value, so, only an *upward*-pointing arrow will be drawn!\n",
      "        \n",
      "        errorevery : int or (int, int), default: 1\n",
      "            draws error bars on a subset of the data. *errorevery* =N draws\n",
      "            error bars on the points (x[::N], y[::N]).\n",
      "            *errorevery* =(start, N) draws error bars on the points\n",
      "            (x[start::N], y[start::N]). e.g. errorevery=(6, 3)\n",
      "            adds error bars to the data at (x[6], x[9], x[12], x[15], ...).\n",
      "            Used to avoid overlapping error bars when two series share x-axis\n",
      "            values.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.ErrorbarContainer`\n",
      "            The container contains:\n",
      "        \n",
      "            - plotline: `.Line2D` instance of x, y plot markers and/or line.\n",
      "            - caplines: A tuple of `.Line2D` instances of the error bar caps.\n",
      "            - barlinecols: A tuple of `.LineCollection` with the horizontal and\n",
      "              vertical error ranges.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All other keyword arguments are passed on to the `~.Axes.plot` call\n",
      "            drawing the markers. For example, this code makes big red squares\n",
      "            with thick green edges::\n",
      "        \n",
      "                x, y, yerr = rand(3, 10)\n",
      "                errorbar(x, y, yerr, marker='s', mfc='red',\n",
      "                         mec='green', ms=20, mew=4)\n",
      "        \n",
      "            where *mfc*, *mec*, *ms* and *mew* are aliases for the longer\n",
      "            property names, *markerfacecolor*, *markeredgecolor*, *markersize*\n",
      "            and *markeredgewidth*.\n",
      "        \n",
      "            Valid kwargs for the marker properties are `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*, *xerr*, *yerr*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    eventplot(positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', *, data=None, **kwargs)\n",
      "        Plot identical parallel lines at the given positions.\n",
      "        \n",
      "        This type of plot is commonly used in neuroscience for representing\n",
      "        neural events, where it is usually called a spike raster, dot raster,\n",
      "        or raster plot.\n",
      "        \n",
      "        However, it is useful in any situation where you wish to show the\n",
      "        timing or position of multiple sets of discrete events, such as the\n",
      "        arrival times of people to a business on each day of the month or the\n",
      "        date of hurricanes each year of the last century.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        positions : array-like or list of array-like\n",
      "            A 1D array-like defines the positions of one sequence of events.\n",
      "        \n",
      "            Multiple groups of events may be passed as a list of array-likes.\n",
      "            Each group can be styled independently by passing lists of values\n",
      "            to *lineoffsets*, *linelengths*, *linewidths*, *colors* and\n",
      "            *linestyles*.\n",
      "        \n",
      "            Note that *positions* can be a 2D array, but in practice different\n",
      "            event groups usually have different counts so that one will use a\n",
      "            list of different-length arrays rather than a 2D array.\n",
      "        \n",
      "        orientation : {'horizontal', 'vertical'}, default: 'horizontal'\n",
      "            The direction of the event sequence:\n",
      "        \n",
      "            - 'horizontal': the events are arranged horizontally.\n",
      "              The indicator lines are vertical.\n",
      "            - 'vertical': the events are arranged vertically.\n",
      "              The indicator lines are horizontal.\n",
      "        \n",
      "        lineoffsets : float or array-like, default: 1\n",
      "            The offset of the center of the lines from the origin, in the\n",
      "            direction orthogonal to *orientation*.\n",
      "        \n",
      "            If *positions* is 2D, this can be a sequence with length matching\n",
      "            the length of *positions*.\n",
      "        \n",
      "        linelengths : float or array-like, default: 1\n",
      "            The total height of the lines (i.e. the lines stretches from\n",
      "            ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).\n",
      "        \n",
      "            If *positions* is 2D, this can be a sequence with length matching\n",
      "            the length of *positions*.\n",
      "        \n",
      "        linewidths : float or array-like, default: :rc:`lines.linewidth`\n",
      "            The line width(s) of the event lines, in points.\n",
      "        \n",
      "            If *positions* is 2D, this can be a sequence with length matching\n",
      "            the length of *positions*.\n",
      "        \n",
      "        colors : color or list of colors, default: :rc:`lines.color`\n",
      "            The color(s) of the event lines.\n",
      "        \n",
      "            If *positions* is 2D, this can be a sequence with length matching\n",
      "            the length of *positions*.\n",
      "        \n",
      "        linestyles : str or tuple or list of such values, default: 'solid'\n",
      "            Default is 'solid'. Valid strings are ['solid', 'dashed',\n",
      "            'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples\n",
      "            should be of the form::\n",
      "        \n",
      "                (offset, onoffseq),\n",
      "        \n",
      "            where *onoffseq* is an even length tuple of on and off ink\n",
      "            in points.\n",
      "        \n",
      "            If *positions* is 2D, this can be a sequence with length matching\n",
      "            the length of *positions*.\n",
      "        \n",
      "        **kwargs\n",
      "            Other keyword arguments are line collection properties.  See\n",
      "            `.LineCollection` for a list of the valid properties.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `.EventCollection`\n",
      "            The `.EventCollection` that were added.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For *linelengths*, *linewidths*, *colors*, and *linestyles*, if only\n",
      "        a single value is given, that value is applied to all lines.  If an\n",
      "        array-like is given, it must have the same length as *positions*, and\n",
      "        each value will be applied to the corresponding row of the array.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        .. plot:: gallery/lines_bars_and_markers/eventplot_demo.py\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *positions*, *lineoffsets*, *linelengths*, *linewidths*, *colors*, *linestyles*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    figimage(X, xo=0, yo=0, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, origin=None, resize=False, **kwargs)\n",
      "        Add a non-resampled image to the figure.\n",
      "        \n",
      "        The image is attached to the lower or upper left corner depending on\n",
      "        *origin*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X\n",
      "            The image data. This is an array of one of the following shapes:\n",
      "        \n",
      "            - MxN: luminance (grayscale) values\n",
      "            - MxNx3: RGB values\n",
      "            - MxNx4: RGBA values\n",
      "        \n",
      "        xo, yo : int\n",
      "            The *x*/*y* image offset in pixels.\n",
      "        \n",
      "        alpha : None or float\n",
      "            The alpha blending value.\n",
      "        \n",
      "        norm : `matplotlib.colors.Normalize`\n",
      "            A `.Normalize` instance to map the luminance to the\n",
      "            interval [0, 1].\n",
      "        \n",
      "        cmap : str or `matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            The colormap to use.\n",
      "        \n",
      "        vmin, vmax : float\n",
      "            If *norm* is not given, these values set the data limits for the\n",
      "            colormap.\n",
      "        \n",
      "        origin : {'upper', 'lower'}, default: :rc:`image.origin`\n",
      "            Indicates where the [0, 0] index of the array is in the upper left\n",
      "            or lower left corner of the axes.\n",
      "        \n",
      "        resize : bool\n",
      "            If *True*, resize the figure to match the given image size.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `matplotlib.image.FigureImage`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Additional kwargs are `.Artist` kwargs passed on to `.FigureImage`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        figimage complements the Axes image (`~matplotlib.axes.Axes.imshow`)\n",
      "        which will be resampled to fit the current Axes.  If you want\n",
      "        a resampled image to fill the entire figure, you can define an\n",
      "        `~matplotlib.axes.Axes` with extent [0, 0, 1, 1].\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            f = plt.figure()\n",
      "            nx = int(f.get_figwidth() * f.dpi)\n",
      "            ny = int(f.get_figheight() * f.dpi)\n",
      "            data = np.random.random((ny, nx))\n",
      "            f.figimage(data)\n",
      "            plt.show()\n",
      "    \n",
      "    figlegend(*args, **kwargs)\n",
      "        Place a legend on the figure.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            figlegend()\n",
      "            figlegend(labels)\n",
      "            figlegend(handles, labels)\n",
      "        \n",
      "        The call signatures correspond to these three different ways to use\n",
      "        this method:\n",
      "        \n",
      "        **1. Automatic detection of elements to be shown in the legend**\n",
      "        \n",
      "        The elements to be added to the legend are automatically determined,\n",
      "        when you do not pass in any extra arguments.\n",
      "        \n",
      "        In this case, the labels are taken from the artist. You can specify\n",
      "        them either at artist creation or by calling the\n",
      "        :meth:`~.Artist.set_label` method on the artist::\n",
      "        \n",
      "            ax.plot([1, 2, 3], label='Inline label')\n",
      "            fig.figlegend()\n",
      "        \n",
      "        or::\n",
      "        \n",
      "            line, = ax.plot([1, 2, 3])\n",
      "            line.set_label('Label via method')\n",
      "            fig.figlegend()\n",
      "        \n",
      "        Specific lines can be excluded from the automatic legend element\n",
      "        selection by defining a label starting with an underscore.\n",
      "        This is default for all artists, so calling `.Figure.legend` without\n",
      "        any arguments and without setting the labels manually will result in\n",
      "        no legend being drawn.\n",
      "        \n",
      "        \n",
      "        **2. Labeling existing plot elements**\n",
      "        \n",
      "        To make a legend for all artists on all Axes, call this function with\n",
      "        an iterable of strings, one for each legend item. For example::\n",
      "        \n",
      "            fig, (ax1, ax2)  = plt.subplots(1, 2)\n",
      "            ax1.plot([1, 3, 5], color='blue')\n",
      "            ax2.plot([2, 4, 6], color='red')\n",
      "            fig.figlegend(['the blues', 'the reds'])\n",
      "        \n",
      "        Note: This call signature is discouraged, because the relation between\n",
      "        plot elements and labels is only implicit by their order and can\n",
      "        easily be mixed up.\n",
      "        \n",
      "        \n",
      "        **3. Explicitly defining the elements in the legend**\n",
      "        \n",
      "        For full control of which artists have a legend entry, it is possible\n",
      "        to pass an iterable of legend artists followed by an iterable of\n",
      "        legend labels respectively::\n",
      "        \n",
      "            fig.figlegend([line1, line2, line3], ['label1', 'label2', 'label3'])\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        handles : list of `.Artist`, optional\n",
      "            A list of Artists (lines, patches) to be added to the legend.\n",
      "            Use this together with *labels*, if you need full control on what\n",
      "            is shown in the legend and the automatic mechanism described above\n",
      "            is not sufficient.\n",
      "        \n",
      "            The length of handles and labels should be the same in this\n",
      "            case. If they are not, they are truncated to the smaller length.\n",
      "        \n",
      "        labels : list of str, optional\n",
      "            A list of labels to show next to the artists.\n",
      "            Use this together with *handles*, if you need full control on what\n",
      "            is shown in the legend and the automatic mechanism described above\n",
      "            is not sufficient.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.legend.Legend`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        loc : str or pair of floats, default: :rc:`legend.loc` ('best' for axes, 'upper right' for figures)\n",
      "            The location of the legend.\n",
      "        \n",
      "            The strings\n",
      "            ``'upper left', 'upper right', 'lower left', 'lower right'``\n",
      "            place the legend at the corresponding corner of the axes/figure.\n",
      "        \n",
      "            The strings\n",
      "            ``'upper center', 'lower center', 'center left', 'center right'``\n",
      "            place the legend at the center of the corresponding edge of the\n",
      "            axes/figure.\n",
      "        \n",
      "            The string ``'center'`` places the legend at the center of the axes/figure.\n",
      "        \n",
      "            The string ``'best'`` places the legend at the location, among the nine\n",
      "            locations defined so far, with the minimum overlap with other drawn\n",
      "            artists.  This option can be quite slow for plots with large amounts of\n",
      "            data; your plotting speed may benefit from providing a specific location.\n",
      "        \n",
      "            The location can also be a 2-tuple giving the coordinates of the lower-left\n",
      "            corner of the legend in axes coordinates (in which case *bbox_to_anchor*\n",
      "            will be ignored).\n",
      "        \n",
      "            For back-compatibility, ``'center right'`` (but no other location) can also\n",
      "            be spelled ``'right'``, and each \"string\" locations can also be given as a\n",
      "            numeric value:\n",
      "        \n",
      "                ===============   =============\n",
      "                Location String   Location Code\n",
      "                ===============   =============\n",
      "                'best'            0\n",
      "                'upper right'     1\n",
      "                'upper left'      2\n",
      "                'lower left'      3\n",
      "                'lower right'     4\n",
      "                'right'           5\n",
      "                'center left'     6\n",
      "                'center right'    7\n",
      "                'lower center'    8\n",
      "                'upper center'    9\n",
      "                'center'          10\n",
      "                ===============   =============\n",
      "        \n",
      "        bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats\n",
      "            Box that is used to position the legend in conjunction with *loc*.\n",
      "            Defaults to `axes.bbox` (if called as a method to `.Axes.legend`) or\n",
      "            `figure.bbox` (if `.Figure.legend`).  This argument allows arbitrary\n",
      "            placement of the legend.\n",
      "        \n",
      "            Bbox coordinates are interpreted in the coordinate system given by\n",
      "            *bbox_transform*, with the default transform\n",
      "            Axes or Figure coordinates, depending on which ``legend`` is called.\n",
      "        \n",
      "            If a 4-tuple or `.BboxBase` is given, then it specifies the bbox\n",
      "            ``(x, y, width, height)`` that the legend is placed in.\n",
      "            To put the legend in the best location in the bottom right\n",
      "            quadrant of the axes (or figure)::\n",
      "        \n",
      "                loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)\n",
      "        \n",
      "            A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at\n",
      "            x, y.  For example, to put the legend's upper right-hand corner in the\n",
      "            center of the axes (or figure) the following keywords can be used::\n",
      "        \n",
      "                loc='upper right', bbox_to_anchor=(0.5, 0.5)\n",
      "        \n",
      "        ncol : int, default: 1\n",
      "            The number of columns that the legend has.\n",
      "        \n",
      "        prop : None or `matplotlib.font_manager.FontProperties` or dict\n",
      "            The font properties of the legend. If None (default), the current\n",
      "            :data:`matplotlib.rcParams` will be used.\n",
      "        \n",
      "        fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "            The font size of the legend. If the value is numeric the size will be the\n",
      "            absolute font size in points. String values are relative to the current\n",
      "            default font size. This argument is only used if *prop* is not specified.\n",
      "        \n",
      "        labelcolor : str or list\n",
      "            The color of the text in the legend. Either a valid color string\n",
      "            (for example, 'red'), or a list of color strings. The labelcolor can\n",
      "            also be made to match the color of the line or marker using 'linecolor',\n",
      "            'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec').\n",
      "        \n",
      "        numpoints : int, default: :rc:`legend.numpoints`\n",
      "            The number of marker points in the legend when creating a legend\n",
      "            entry for a `.Line2D` (line).\n",
      "        \n",
      "        scatterpoints : int, default: :rc:`legend.scatterpoints`\n",
      "            The number of marker points in the legend when creating\n",
      "            a legend entry for a `.PathCollection` (scatter plot).\n",
      "        \n",
      "        scatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``\n",
      "            The vertical offset (relative to the font size) for the markers\n",
      "            created for a scatter plot legend entry. 0.0 is at the base the\n",
      "            legend text, and 1.0 is at the top. To draw all markers at the\n",
      "            same height, set to ``[0.5]``.\n",
      "        \n",
      "        markerscale : float, default: :rc:`legend.markerscale`\n",
      "            The relative size of legend markers compared with the originally\n",
      "            drawn ones.\n",
      "        \n",
      "        markerfirst : bool, default: True\n",
      "            If *True*, legend marker is placed to the left of the legend label.\n",
      "            If *False*, legend marker is placed to the right of the legend label.\n",
      "        \n",
      "        frameon : bool, default: :rc:`legend.frameon`\n",
      "            Whether the legend should be drawn on a patch (frame).\n",
      "        \n",
      "        fancybox : bool, default: :rc:`legend.fancybox`\n",
      "            Whether round edges should be enabled around the `~.FancyBboxPatch` which\n",
      "            makes up the legend's background.\n",
      "        \n",
      "        shadow : bool, default: :rc:`legend.shadow`\n",
      "            Whether to draw a shadow behind the legend.\n",
      "        \n",
      "        framealpha : float, default: :rc:`legend.framealpha`\n",
      "            The alpha transparency of the legend's background.\n",
      "            If *shadow* is activated and *framealpha* is ``None``, the default value is\n",
      "            ignored.\n",
      "        \n",
      "        facecolor : \"inherit\" or color, default: :rc:`legend.facecolor`\n",
      "            The legend's background color.\n",
      "            If ``\"inherit\"``, use :rc:`axes.facecolor`.\n",
      "        \n",
      "        edgecolor : \"inherit\" or color, default: :rc:`legend.edgecolor`\n",
      "            The legend's background patch edge color.\n",
      "            If ``\"inherit\"``, use take :rc:`axes.edgecolor`.\n",
      "        \n",
      "        mode : {\"expand\", None}\n",
      "            If *mode* is set to ``\"expand\"`` the legend will be horizontally\n",
      "            expanded to fill the axes area (or *bbox_to_anchor* if defines\n",
      "            the legend's size).\n",
      "        \n",
      "        bbox_transform : None or `matplotlib.transforms.Transform`\n",
      "            The transform for the bounding box (*bbox_to_anchor*). For a value\n",
      "            of ``None`` (default) the Axes'\n",
      "            :data:`~matplotlib.axes.Axes.transAxes` transform will be used.\n",
      "        \n",
      "        title : str or None\n",
      "            The legend's title. Default is no title (``None``).\n",
      "        \n",
      "        title_fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: :rc:`legend.title_fontsize`\n",
      "            The font size of the legend's title.\n",
      "        \n",
      "        borderpad : float, default: :rc:`legend.borderpad`\n",
      "            The fractional whitespace inside the legend border, in font-size units.\n",
      "        \n",
      "        labelspacing : float, default: :rc:`legend.labelspacing`\n",
      "            The vertical space between the legend entries, in font-size units.\n",
      "        \n",
      "        handlelength : float, default: :rc:`legend.handlelength`\n",
      "            The length of the legend handles, in font-size units.\n",
      "        \n",
      "        handletextpad : float, default: :rc:`legend.handletextpad`\n",
      "            The pad between the legend handle and text, in font-size units.\n",
      "        \n",
      "        borderaxespad : float, default: :rc:`legend.borderaxespad`\n",
      "            The pad between the axes and legend border, in font-size units.\n",
      "        \n",
      "        columnspacing : float, default: :rc:`legend.columnspacing`\n",
      "            The spacing between columns, in font-size units.\n",
      "        \n",
      "        handler_map : dict or None\n",
      "            The custom dictionary mapping instances or types to a legend\n",
      "            handler. This *handler_map* updates the default handler map\n",
      "            found at `matplotlib.legend.Legend.get_legend_handler_map`.\n",
      "        \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .Axes.legend\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Some artists are not supported by this function.  See\n",
      "        :doc:`/tutorials/intermediate/legend_guide` for details.\n",
      "    \n",
      "    fignum_exists(num)\n",
      "        Return whether the figure with the given id exists.\n",
      "    \n",
      "    figtext(x, y, s, fontdict=None, **kwargs)\n",
      "        Add text to figure.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : float\n",
      "            The position to place the text. By default, this is in figure\n",
      "            coordinates, floats in [0, 1]. The coordinate system can be changed\n",
      "            using the *transform* keyword.\n",
      "        \n",
      "        s : str\n",
      "            The text string.\n",
      "        \n",
      "        fontdict : dict, optional\n",
      "            A dictionary to override the default text properties. If not given,\n",
      "            the defaults are determined by :rc:`font.*`. Properties passed as\n",
      "            *kwargs* override the corresponding ones given in *fontdict*.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~.text.Text`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.text.Text` properties\n",
      "            Other miscellaneous text parameters.\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            backgroundcolor: color\n",
      "            bbox: dict with properties for `.patches.FancyBboxPatch`\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            figure: `.Figure`\n",
      "            fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}\n",
      "            fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`\n",
      "            fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "            fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}\n",
      "            fontstyle or style: {'normal', 'italic', 'oblique'}\n",
      "            fontvariant or variant: {'normal', 'small-caps'}\n",
      "            fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}\n",
      "            gid: str\n",
      "            horizontalalignment or ha: {'center', 'right', 'left'}\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linespacing: float (multiple of font size)\n",
      "            math_fontfamily: str\n",
      "            multialignment or ma: {'left', 'right', 'center'}\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            position: (float, float)\n",
      "            rasterized: bool\n",
      "            rotation: float or {'vertical', 'horizontal'}\n",
      "            rotation_mode: {None, 'default', 'anchor'}\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            text: object\n",
      "            transform: `.Transform`\n",
      "            transform_rotates_text: bool\n",
      "            url: str\n",
      "            usetex: bool or None\n",
      "            verticalalignment or va: {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      "            visible: bool\n",
      "            wrap: bool\n",
      "            x: float\n",
      "            y: float\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .Axes.text\n",
      "        .pyplot.text\n",
      "    \n",
      "    figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True, FigureClass=<class 'matplotlib.figure.Figure'>, clear=False, **kwargs)\n",
      "        Create a new figure, or activate an existing figure.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        num : int or str or `.Figure`, optional\n",
      "            A unique identifier for the figure.\n",
      "        \n",
      "            If a figure with that identifier already exists, this figure is made\n",
      "            active and returned. An integer refers to the ``Figure.number``\n",
      "            attribute, a string refers to the figure label.\n",
      "        \n",
      "            If there is no figure with the identifier or *num* is not given, a new\n",
      "            figure is created, made active and returned.  If *num* is an int, it\n",
      "            will be used for the ``Figure.number`` attribute, otherwise, an\n",
      "            auto-generated integer value is used (starting at 1 and incremented\n",
      "            for each new figure). If *num* is a string, the figure label and the\n",
      "            window title is set to this value.\n",
      "        \n",
      "        figsize : (float, float), default: :rc:`figure.figsize`\n",
      "            Width, height in inches.\n",
      "        \n",
      "        dpi : float, default: :rc:`figure.dpi`\n",
      "            The resolution of the figure in dots-per-inch.\n",
      "        \n",
      "        facecolor : color, default: :rc:`figure.facecolor`\n",
      "            The background color.\n",
      "        \n",
      "        edgecolor : color, default: :rc:`figure.edgecolor`\n",
      "            The border color.\n",
      "        \n",
      "        frameon : bool, default: True\n",
      "            If False, suppress drawing the figure frame.\n",
      "        \n",
      "        FigureClass : subclass of `~matplotlib.figure.Figure`\n",
      "            Optionally use a custom `.Figure` instance.\n",
      "        \n",
      "        clear : bool, default: False\n",
      "            If True and the figure already exists, then it is cleared.\n",
      "        \n",
      "        tight_layout : bool or dict, default: :rc:`figure.autolayout`\n",
      "            If ``False`` use *subplotpars*. If ``True`` adjust subplot\n",
      "            parameters using `.tight_layout` with default padding.\n",
      "            When providing a dict containing the keys ``pad``, ``w_pad``,\n",
      "            ``h_pad``, and ``rect``, the default `.tight_layout` paddings\n",
      "            will be overridden.\n",
      "        \n",
      "        constrained_layout : bool, default: :rc:`figure.constrained_layout.use`\n",
      "            If ``True`` use constrained layout to adjust positioning of plot\n",
      "            elements.  Like ``tight_layout``, but designed to be more\n",
      "            flexible.  See\n",
      "            :doc:`/tutorials/intermediate/constrainedlayout_guide`\n",
      "            for examples.  (Note: does not work with `add_subplot` or\n",
      "            `~.pyplot.subplot2grid`.)\n",
      "        \n",
      "        \n",
      "        **kwargs : optional\n",
      "            See `~.matplotlib.figure.Figure` for other possible arguments.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.figure.Figure`\n",
      "            The `.Figure` instance returned will also be passed to\n",
      "            new_figure_manager in the backends, which allows to hook custom\n",
      "            `.Figure` classes into the pyplot interface. Additional kwargs will be\n",
      "            passed to the `.Figure` init function.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If you are creating many figures, make sure you explicitly call\n",
      "        `.pyplot.close` on the figures you are not using, because this will\n",
      "        enable pyplot to properly clean up the memory.\n",
      "        \n",
      "        `~matplotlib.rcParams` defines the default values, which can be modified\n",
      "        in the matplotlibrc file.\n",
      "    \n",
      "    fill(*args, data=None, **kwargs)\n",
      "        Plot filled polygons.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        *args : sequence of x, y, [color]\n",
      "            Each polygon is defined by the lists of *x* and *y* positions of\n",
      "            its nodes, optionally followed by a *color* specifier. See\n",
      "            :mod:`matplotlib.colors` for supported color specifiers. The\n",
      "            standard color cycle is used for polygons without a color\n",
      "            specifier.\n",
      "        \n",
      "            You can plot multiple polygons by providing multiple *x*, *y*,\n",
      "            *[color]* groups.\n",
      "        \n",
      "            For example, each of the following is legal::\n",
      "        \n",
      "                ax.fill(x, y)                    # a polygon with default color\n",
      "                ax.fill(x, y, \"b\")               # a blue polygon\n",
      "                ax.fill(x, y, x2, y2)            # two polygons\n",
      "                ax.fill(x, y, \"b\", x2, y2, \"r\")  # a blue and a red polygon\n",
      "        \n",
      "        data : indexable object, optional\n",
      "            An object with labelled data. If given, provide the label names to\n",
      "            plot in *x* and *y*, e.g.::\n",
      "        \n",
      "                ax.fill(\"time\", \"signal\",\n",
      "                        data={\"time\": [0, 1, 2], \"signal\": [0, 1, 0]})\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `~matplotlib.patches.Polygon`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Polygon` properties\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Use :meth:`fill_between` if you would like to fill the region between\n",
      "        two curves.\n",
      "    \n",
      "    fill_between(x, y1, y2=0, where=None, interpolate=False, step=None, *, data=None, **kwargs)\n",
      "        Fill the area between two horizontal curves.\n",
      "        \n",
      "        The curves are defined by the points (*x*, *y1*) and (*x*,\n",
      "        *y2*).  This creates one or multiple polygons describing the filled\n",
      "        area.\n",
      "        \n",
      "        You may exclude some horizontal sections from filling using *where*.\n",
      "        \n",
      "        By default, the edges connect the given points directly.  Use *step*\n",
      "        if the filling should be a step function, i.e. constant in between\n",
      "        *x*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array (length N)\n",
      "            The x coordinates of the nodes defining the curves.\n",
      "        \n",
      "        y1 : array (length N) or scalar\n",
      "            The y coordinates of the nodes defining the first curve.\n",
      "        \n",
      "        y2 : array (length N) or scalar, default: 0\n",
      "            The y coordinates of the nodes defining the second curve.\n",
      "        \n",
      "        where : array of bool (length N), optional\n",
      "            Define *where* to exclude some horizontal regions from being filled.\n",
      "            The filled regions are defined by the coordinates ``x[where]``.\n",
      "            More precisely, fill between ``x[i]`` and ``x[i+1]`` if\n",
      "            ``where[i] and where[i+1]``.  Note that this definition implies\n",
      "            that an isolated *True* value between two *False* values in *where*\n",
      "            will not result in filling.  Both sides of the *True* position\n",
      "            remain unfilled due to the adjacent *False* values.\n",
      "        \n",
      "        interpolate : bool, default: False\n",
      "            This option is only relevant if *where* is used and the two curves\n",
      "            are crossing each other.\n",
      "        \n",
      "            Semantically, *where* is often used for *y1* > *y2* or\n",
      "            similar.  By default, the nodes of the polygon defining the filled\n",
      "            region will only be placed at the positions in the *x* array.\n",
      "            Such a polygon cannot describe the above semantics close to the\n",
      "            intersection.  The x-sections containing the intersection are\n",
      "            simply clipped.\n",
      "        \n",
      "            Setting *interpolate* to *True* will calculate the actual\n",
      "            intersection point and extend the filled region up to this point.\n",
      "        \n",
      "        step : {'pre', 'post', 'mid'}, optional\n",
      "            Define *step* if the filling should be a step function,\n",
      "            i.e. constant in between *x*.  The value determines where the\n",
      "            step will occur:\n",
      "        \n",
      "            - 'pre': The y value is continued constantly to the left from\n",
      "              every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the\n",
      "              value ``y[i]``.\n",
      "            - 'post': The y value is continued constantly to the right from\n",
      "              every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the\n",
      "              value ``y[i]``.\n",
      "            - 'mid': Steps occur half-way between the *x* positions.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.PolyCollection`\n",
      "            A `.PolyCollection` containing the plotted polygons.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All other keyword arguments are passed on to `.PolyCollection`.\n",
      "            They control the `.Polygon` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fill_between : Fill between two sets of y-values.\n",
      "        fill_betweenx : Fill between two sets of x-values.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [notes section required to get data note injection right]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y1*, *y2*, *where*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    fill_betweenx(y, x1, x2=0, where=None, step=None, interpolate=False, *, data=None, **kwargs)\n",
      "        Fill the area between two vertical curves.\n",
      "        \n",
      "        The curves are defined by the points (*y*, *x1*) and (*y*,\n",
      "        *x2*).  This creates one or multiple polygons describing the filled\n",
      "        area.\n",
      "        \n",
      "        You may exclude some vertical sections from filling using *where*.\n",
      "        \n",
      "        By default, the edges connect the given points directly.  Use *step*\n",
      "        if the filling should be a step function, i.e. constant in between\n",
      "        *y*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : array (length N)\n",
      "            The y coordinates of the nodes defining the curves.\n",
      "        \n",
      "        x1 : array (length N) or scalar\n",
      "            The x coordinates of the nodes defining the first curve.\n",
      "        \n",
      "        x2 : array (length N) or scalar, default: 0\n",
      "            The x coordinates of the nodes defining the second curve.\n",
      "        \n",
      "        where : array of bool (length N), optional\n",
      "            Define *where* to exclude some vertical regions from being filled.\n",
      "            The filled regions are defined by the coordinates ``y[where]``.\n",
      "            More precisely, fill between ``y[i]`` and ``y[i+1]`` if\n",
      "            ``where[i] and where[i+1]``.  Note that this definition implies\n",
      "            that an isolated *True* value between two *False* values in *where*\n",
      "            will not result in filling.  Both sides of the *True* position\n",
      "            remain unfilled due to the adjacent *False* values.\n",
      "        \n",
      "        interpolate : bool, default: False\n",
      "            This option is only relevant if *where* is used and the two curves\n",
      "            are crossing each other.\n",
      "        \n",
      "            Semantically, *where* is often used for *x1* > *x2* or\n",
      "            similar.  By default, the nodes of the polygon defining the filled\n",
      "            region will only be placed at the positions in the *y* array.\n",
      "            Such a polygon cannot describe the above semantics close to the\n",
      "            intersection.  The y-sections containing the intersection are\n",
      "            simply clipped.\n",
      "        \n",
      "            Setting *interpolate* to *True* will calculate the actual\n",
      "            intersection point and extend the filled region up to this point.\n",
      "        \n",
      "        step : {'pre', 'post', 'mid'}, optional\n",
      "            Define *step* if the filling should be a step function,\n",
      "            i.e. constant in between *y*.  The value determines where the\n",
      "            step will occur:\n",
      "        \n",
      "            - 'pre': The y value is continued constantly to the left from\n",
      "              every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the\n",
      "              value ``y[i]``.\n",
      "            - 'post': The y value is continued constantly to the right from\n",
      "              every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the\n",
      "              value ``y[i]``.\n",
      "            - 'mid': Steps occur half-way between the *x* positions.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.PolyCollection`\n",
      "            A `.PolyCollection` containing the plotted polygons.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All other keyword arguments are passed on to `.PolyCollection`.\n",
      "            They control the `.Polygon` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fill_between : Fill between two sets of y-values.\n",
      "        fill_betweenx : Fill between two sets of x-values.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [notes section required to get data note injection right]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *y*, *x1*, *x2*, *where*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    findobj(o=None, match=None, include_self=True)\n",
      "        Find artist objects.\n",
      "        \n",
      "        Recursively find all `.Artist` instances contained in the artist.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        match\n",
      "            A filter criterion for the matches. This can be\n",
      "        \n",
      "            - *None*: Return all objects contained in artist.\n",
      "            - A function with signature ``def match(artist: Artist) -> bool``.\n",
      "              The result will only contain artists for which the function\n",
      "              returns *True*.\n",
      "            - A class instance: e.g., `.Line2D`. The result will only contain\n",
      "              artists of this class or its subclasses (``isinstance`` check).\n",
      "        \n",
      "        include_self : bool\n",
      "            Include *self* in the list to be checked for a match.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `.Artist`\n",
      "    \n",
      "    flag()\n",
      "        Set the colormap to 'flag'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    gca(**kwargs)\n",
      "        Get the current Axes, creating one if necessary.\n",
      "        \n",
      "        The following kwargs are supported for ensuring the returned Axes\n",
      "        adheres to the given projection etc., and for Axes creation if\n",
      "        the active Axes does not exist:\n",
      "        \n",
      "        Properties:\n",
      "            adjustable: {'box', 'datalim'}\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}\n",
      "            animated: bool\n",
      "            aspect: {'auto', 'equal'} or float\n",
      "            autoscale_on: bool\n",
      "            autoscalex_on: bool\n",
      "            autoscaley_on: bool\n",
      "            axes_locator: Callable[[Axes, Renderer], Bbox]\n",
      "            axisbelow: bool or 'line'\n",
      "            box_aspect: float or None\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            contains: unknown\n",
      "            facecolor or fc: color\n",
      "            figure: `.Figure`\n",
      "            frame_on: bool\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            navigate: bool\n",
      "            navigate_mode: unknown\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n",
      "            prop_cycle: unknown\n",
      "            rasterization_zorder: float or None\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            title: str\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xbound: unknown\n",
      "            xlabel: str\n",
      "            xlim: (bottom: float, top: float)\n",
      "            xmargin: float greater than -0.5\n",
      "            xscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            xticklabels: unknown\n",
      "            xticks: unknown\n",
      "            ybound: unknown\n",
      "            ylabel: str\n",
      "            ylim: (bottom: float, top: float)\n",
      "            ymargin: float greater than -0.5\n",
      "            yscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            yticklabels: unknown\n",
      "            yticks: unknown\n",
      "            zorder: float\n",
      "    \n",
      "    gcf()\n",
      "        Get the current figure.\n",
      "        \n",
      "        If no current figure exists, a new one is created using\n",
      "        `~.pyplot.figure()`.\n",
      "    \n",
      "    gci()\n",
      "        Get the current colorable artist.\n",
      "        \n",
      "        Specifically, returns the current `.ScalarMappable` instance (`.Image`\n",
      "        created by `imshow` or `figimage`, `.Collection` created by `pcolor` or\n",
      "        `scatter`, etc.), or *None* if no such instance has been defined.\n",
      "        \n",
      "        The current image is an attribute of the current Axes, or the nearest\n",
      "        earlier Axes in the current figure that contains an image.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Historically, the only colorable artists were images; hence the name\n",
      "        ``gci`` (get current image).\n",
      "    \n",
      "    get(obj, *args, **kwargs)\n",
      "        Return the value of an `.Artist`'s *property*, or print all of them.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        obj : `.Artist`\n",
      "            The queried artist; e.g., a `.Line2D`, a `.Text`, or an `~.axes.Axes`.\n",
      "        \n",
      "        property : str or None, default: None\n",
      "            If *property* is 'somename', this function returns\n",
      "            ``obj.get_somename()``.\n",
      "        \n",
      "            If is is None (or unset), it *prints* all gettable properties from\n",
      "            *obj*.  Many properties have aliases for shorter typing, e.g. 'lw' is\n",
      "            an alias for 'linewidth'.  In the output, aliases and full property\n",
      "            names will be listed as:\n",
      "        \n",
      "              property or alias = value\n",
      "        \n",
      "            e.g.:\n",
      "        \n",
      "              linewidth or lw = 2\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        setp\n",
      "    \n",
      "    get_current_fig_manager()\n",
      "        Return the figure manager of the current figure.\n",
      "        \n",
      "        The figure manager is a container for the actual backend-depended window\n",
      "        that displays the figure on screen.\n",
      "        \n",
      "        If no current figure exists, a new one is created, and its figure\n",
      "        manager is returned.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.FigureManagerBase` or backend-dependent subclass thereof\n",
      "    \n",
      "    get_figlabels()\n",
      "        Return a list of existing figure labels.\n",
      "    \n",
      "    get_fignums()\n",
      "        Return a list of existing figure numbers.\n",
      "    \n",
      "    get_plot_commands()\n",
      "        Get a sorted list of all of the plotting commands.\n",
      "    \n",
      "    getp(obj, *args, **kwargs)\n",
      "        Return the value of an `.Artist`'s *property*, or print all of them.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        obj : `.Artist`\n",
      "            The queried artist; e.g., a `.Line2D`, a `.Text`, or an `~.axes.Axes`.\n",
      "        \n",
      "        property : str or None, default: None\n",
      "            If *property* is 'somename', this function returns\n",
      "            ``obj.get_somename()``.\n",
      "        \n",
      "            If is is None (or unset), it *prints* all gettable properties from\n",
      "            *obj*.  Many properties have aliases for shorter typing, e.g. 'lw' is\n",
      "            an alias for 'linewidth'.  In the output, aliases and full property\n",
      "            names will be listed as:\n",
      "        \n",
      "              property or alias = value\n",
      "        \n",
      "            e.g.:\n",
      "        \n",
      "              linewidth or lw = 2\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        setp\n",
      "    \n",
      "    ginput(n=1, timeout=30, show_clicks=True, mouse_add=<MouseButton.LEFT: 1>, mouse_pop=<MouseButton.RIGHT: 3>, mouse_stop=<MouseButton.MIDDLE: 2>)\n",
      "        Blocking call to interact with a figure.\n",
      "        \n",
      "        Wait until the user clicks *n* times on the figure, and return the\n",
      "        coordinates of each click in a list.\n",
      "        \n",
      "        There are three possible interactions:\n",
      "        \n",
      "        - Add a point.\n",
      "        - Remove the most recently added point.\n",
      "        - Stop the interaction and return the points added so far.\n",
      "        \n",
      "        The actions are assigned to mouse buttons via the arguments\n",
      "        *mouse_add*, *mouse_pop* and *mouse_stop*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int, default: 1\n",
      "            Number of mouse clicks to accumulate. If negative, accumulate\n",
      "            clicks until the input is terminated manually.\n",
      "        timeout : float, default: 30 seconds\n",
      "            Number of seconds to wait before timing out. If zero or negative\n",
      "            will never timeout.\n",
      "        show_clicks : bool, default: True\n",
      "            If True, show a red cross at the location of each click.\n",
      "        mouse_add : `.MouseButton` or None, default: `.MouseButton.LEFT`\n",
      "            Mouse button used to add points.\n",
      "        mouse_pop : `.MouseButton` or None, default: `.MouseButton.RIGHT`\n",
      "            Mouse button used to remove the most recently added point.\n",
      "        mouse_stop : `.MouseButton` or None, default: `.MouseButton.MIDDLE`\n",
      "            Mouse button used to stop input.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of tuples\n",
      "            A list of the clicked (x, y) coordinates.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The keyboard can also be used to select points in case your mouse\n",
      "        does not have one or more of the buttons.  The delete and backspace\n",
      "        keys act like right clicking (i.e., remove last point), the enter key\n",
      "        terminates input and any other key (not already used by the window\n",
      "        manager) selects a point.\n",
      "    \n",
      "    gray()\n",
      "        Set the colormap to 'gray'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    grid(b=None, which='major', axis='both', **kwargs)\n",
      "        Configure the grid lines.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        b : bool or None, optional\n",
      "            Whether to show the grid lines. If any *kwargs* are supplied,\n",
      "            it is assumed you want the grid on and *b* will be set to True.\n",
      "        \n",
      "            If *b* is *None* and there are no *kwargs*, this toggles the\n",
      "            visibility of the lines.\n",
      "        \n",
      "        which : {'major', 'minor', 'both'}, optional\n",
      "            The grid lines to apply the changes on.\n",
      "        \n",
      "        axis : {'both', 'x', 'y'}, optional\n",
      "            The axis to apply the changes on.\n",
      "        \n",
      "        **kwargs : `.Line2D` properties\n",
      "            Define the line properties of the grid, e.g.::\n",
      "        \n",
      "                grid(color='r', linestyle='-', linewidth=2)\n",
      "        \n",
      "            Valid keyword arguments are:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The axis is drawn as a unit, so the effective zorder for drawing the\n",
      "        grid is determined by the zorder of each axis, not by the zorder of the\n",
      "        `.Line2D` objects comprising the grid.  Therefore, to set grid zorder,\n",
      "        use `.set_axisbelow` or, for more control, call the\n",
      "        `~.Artist.set_zorder` method of each axis.\n",
      "    \n",
      "    hexbin(x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=<function mean at 0x0000018043F3D9D0>, mincnt=None, marginals=False, *, data=None, **kwargs)\n",
      "        Make a 2D hexagonal binning plot of points *x*, *y*.\n",
      "        \n",
      "        If *C* is *None*, the value of the hexagon is determined by the number\n",
      "        of points in the hexagon. Otherwise, *C* specifies values at the\n",
      "        coordinate (x[i], y[i]). For each hexagon, these values are reduced\n",
      "        using *reduce_C_function*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array-like\n",
      "            The data positions. *x* and *y* must be of the same length.\n",
      "        \n",
      "        C : array-like, optional\n",
      "            If given, these values are accumulated in the bins. Otherwise,\n",
      "            every point has a value of 1. Must be of the same length as *x*\n",
      "            and *y*.\n",
      "        \n",
      "        gridsize : int or (int, int), default: 100\n",
      "            If a single int, the number of hexagons in the *x*-direction.\n",
      "            The number of hexagons in the *y*-direction is chosen such that\n",
      "            the hexagons are approximately regular.\n",
      "        \n",
      "            Alternatively, if a tuple (*nx*, *ny*), the number of hexagons\n",
      "            in the *x*-direction and the *y*-direction.\n",
      "        \n",
      "        bins : 'log' or int or sequence, default: None\n",
      "            Discretization of the hexagon values.\n",
      "        \n",
      "            - If *None*, no binning is applied; the color of each hexagon\n",
      "              directly corresponds to its count value.\n",
      "            - If 'log', use a logarithmic scale for the colormap.\n",
      "              Internally, :math:`log_{10}(i+1)` is used to determine the\n",
      "              hexagon color. This is equivalent to ``norm=LogNorm()``.\n",
      "            - If an integer, divide the counts in the specified number\n",
      "              of bins, and color the hexagons accordingly.\n",
      "            - If a sequence of values, the values of the lower bound of\n",
      "              the bins to be used.\n",
      "        \n",
      "        xscale : {'linear', 'log'}, default: 'linear'\n",
      "            Use a linear or log10 scale on the horizontal axis.\n",
      "        \n",
      "        yscale : {'linear', 'log'}, default: 'linear'\n",
      "            Use a linear or log10 scale on the vertical axis.\n",
      "        \n",
      "        mincnt : int > 0, default: *None*\n",
      "            If not *None*, only display cells with more than *mincnt*\n",
      "            number of points in the cell.\n",
      "        \n",
      "        marginals : bool, default: *False*\n",
      "            If marginals is *True*, plot the marginal density as\n",
      "            colormapped rectangles along the bottom of the x-axis and\n",
      "            left of the y-axis.\n",
      "        \n",
      "        extent : float, default: *None*\n",
      "            The limits of the bins. The default assigns the limits\n",
      "            based on *gridsize*, *x*, *y*, *xscale* and *yscale*.\n",
      "        \n",
      "            If *xscale* or *yscale* is set to 'log', the limits are\n",
      "            expected to be the exponent for a power of 10. E.g. for\n",
      "            x-limits of 1 and 50 in 'linear' scale and y-limits\n",
      "            of 10 and 1000 in 'log' scale, enter (1, 50, 1, 3).\n",
      "        \n",
      "            Order of scalars is (left, right, bottom, top).\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.collections.PolyCollection`\n",
      "            A `.PolyCollection` defining the hexagonal bins.\n",
      "        \n",
      "            - `.PolyCollection.get_offsets` contains a Mx2 array containing\n",
      "              the x, y positions of the M hexagon centers.\n",
      "            - `.PolyCollection.get_array` contains the values of the M\n",
      "              hexagons.\n",
      "        \n",
      "            If *marginals* is *True*, horizontal\n",
      "            bar and vertical bar (both PolyCollections) will be attached\n",
      "            to the return collection as attributes *hbar* and *vbar*.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            The Colormap instance or registered colormap name used to map\n",
      "            the bin values to colors.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            The Normalize instance scales the bin values to the canonical\n",
      "            colormap range [0, 1] for mapping to colors. By default, the data\n",
      "            range is mapped to the colorbar range using linear scaling.\n",
      "        \n",
      "        vmin, vmax : float, default: None\n",
      "            The colorbar range. If *None*, suitable min/max values are\n",
      "            automatically chosen by the `~.Normalize` instance (defaults to\n",
      "            the respective min/max values of the bins in case of the default\n",
      "            linear scaling).\n",
      "            It is deprecated to use *vmin*/*vmax* when *norm* is given.\n",
      "        \n",
      "        alpha : float between 0 and 1, optional\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        linewidths : float, default: *None*\n",
      "            If *None*, defaults to 1.0.\n",
      "        \n",
      "        edgecolors : {'face', 'none', *None*} or color, default: 'face'\n",
      "            The color of the hexagon edges. Possible values are:\n",
      "        \n",
      "            - 'face': Draw the edges in the same color as the fill color.\n",
      "            - 'none': No edges are drawn. This can sometimes lead to unsightly\n",
      "              unpainted pixels between the hexagons.\n",
      "            - *None*: Draw outlines in the default color.\n",
      "            - An explicit color.\n",
      "        \n",
      "        reduce_C_function : callable, default: `numpy.mean`\n",
      "            The function to aggregate *C* within the bins. It is ignored if\n",
      "            *C* is not given. This must have the signature::\n",
      "        \n",
      "                def reduce_C_function(C: array) -> float\n",
      "        \n",
      "            Commonly used functions are:\n",
      "        \n",
      "            - `numpy.mean`: average of the points\n",
      "            - `numpy.sum`: integral of the point values\n",
      "            - `numpy.amax`: value taken from the largest point\n",
      "        \n",
      "        **kwargs : `~matplotlib.collections.PolyCollection` properties\n",
      "            All other keyword arguments are passed on to `.PolyCollection`:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*, *C*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    hist(x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)\n",
      "        Plot a histogram.\n",
      "        \n",
      "        Compute and draw the histogram of *x*.  The return value is a tuple\n",
      "        (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*,\n",
      "        *patches1*, ...]) if the input contains multiple data.  See the\n",
      "        documentation of the *weights* parameter to draw a histogram of\n",
      "        already-binned data.\n",
      "        \n",
      "        Multiple data can be provided via *x* as a list of datasets\n",
      "        of potentially different length ([*x0*, *x1*, ...]), or as\n",
      "        a 2D ndarray in which each column is a dataset.  Note that\n",
      "        the ndarray form is transposed relative to the list form.\n",
      "        \n",
      "        Masked arrays are not supported.\n",
      "        \n",
      "        The *bins*, *range*, *weights*, and *density* parameters behave as in\n",
      "        `numpy.histogram`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : (n,) array or sequence of (n,) arrays\n",
      "            Input values, this takes either a single array or a sequence of\n",
      "            arrays which are not required to be of the same length.\n",
      "        \n",
      "        bins : int or sequence or str, default: :rc:`hist.bins`\n",
      "            If *bins* is an integer, it defines the number of equal-width bins\n",
      "            in the range.\n",
      "        \n",
      "            If *bins* is a sequence, it defines the bin edges, including the\n",
      "            left edge of the first bin and the right edge of the last bin;\n",
      "            in this case, bins may be unequally spaced.  All but the last\n",
      "            (righthand-most) bin is half-open.  In other words, if *bins* is::\n",
      "        \n",
      "                [1, 2, 3, 4]\n",
      "        \n",
      "            then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      "            the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      "            *includes* 4.\n",
      "        \n",
      "            If *bins* is a string, it is one of the binning strategies\n",
      "            supported by `numpy.histogram_bin_edges`: 'auto', 'fd', 'doane',\n",
      "            'scott', 'stone', 'rice', 'sturges', or 'sqrt'.\n",
      "        \n",
      "        range : tuple or None, default: None\n",
      "            The lower and upper range of the bins. Lower and upper outliers\n",
      "            are ignored. If not provided, *range* is ``(x.min(), x.max())``.\n",
      "            Range has no effect if *bins* is a sequence.\n",
      "        \n",
      "            If *bins* is a sequence or *range* is specified, autoscaling\n",
      "            is based on the specified bin range instead of the\n",
      "            range of x.\n",
      "        \n",
      "        density : bool, default: False\n",
      "            If ``True``, draw and return a probability density: each bin\n",
      "            will display the bin's raw count divided by the total number of\n",
      "            counts *and the bin width*\n",
      "            (``density = counts / (sum(counts) * np.diff(bins))``),\n",
      "            so that the area under the histogram integrates to 1\n",
      "            (``np.sum(density * np.diff(bins)) == 1``).\n",
      "        \n",
      "            If *stacked* is also ``True``, the sum of the histograms is\n",
      "            normalized to 1.\n",
      "        \n",
      "        weights : (n,) array-like or None, default: None\n",
      "            An array of weights, of the same shape as *x*.  Each value in\n",
      "            *x* only contributes its associated weight towards the bin count\n",
      "            (instead of 1).  If *density* is ``True``, the weights are\n",
      "            normalized, so that the integral of the density over the range\n",
      "            remains 1.\n",
      "        \n",
      "            This parameter can be used to draw a histogram of data that has\n",
      "            already been binned, e.g. using `numpy.histogram` (by treating each\n",
      "            bin as a single point with a weight equal to its count) ::\n",
      "        \n",
      "                counts, bins = np.histogram(data)\n",
      "                plt.hist(bins[:-1], bins, weights=counts)\n",
      "        \n",
      "            (or you may alternatively use `~.bar()`).\n",
      "        \n",
      "        cumulative : bool or -1, default: False\n",
      "            If ``True``, then a histogram is computed where each bin gives the\n",
      "            counts in that bin plus all bins for smaller values. The last bin\n",
      "            gives the total number of datapoints.\n",
      "        \n",
      "            If *density* is also ``True`` then the histogram is normalized such\n",
      "            that the last bin equals 1.\n",
      "        \n",
      "            If *cumulative* is a number less than 0 (e.g., -1), the direction\n",
      "            of accumulation is reversed.  In this case, if *density* is also\n",
      "            ``True``, then the histogram is normalized such that the first bin\n",
      "            equals 1.\n",
      "        \n",
      "        bottom : array-like, scalar, or None, default: None\n",
      "            Location of the bottom of each bin, ie. bins are drawn from\n",
      "            ``bottom`` to ``bottom + hist(x, bins)`` If a scalar, the bottom\n",
      "            of each bin is shifted by the same amount. If an array, each bin\n",
      "            is shifted independently and the length of bottom must match the\n",
      "            number of bins. If None, defaults to 0.\n",
      "        \n",
      "        histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, default: 'bar'\n",
      "            The type of histogram to draw.\n",
      "        \n",
      "            - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      "              are given the bars are arranged side by side.\n",
      "            - 'barstacked' is a bar-type histogram where multiple\n",
      "              data are stacked on top of each other.\n",
      "            - 'step' generates a lineplot that is by default unfilled.\n",
      "            - 'stepfilled' generates a lineplot that is by default filled.\n",
      "        \n",
      "        align : {'left', 'mid', 'right'}, default: 'mid'\n",
      "            The horizontal alignment of the histogram bars.\n",
      "        \n",
      "            - 'left': bars are centered on the left bin edges.\n",
      "            - 'mid': bars are centered between the bin edges.\n",
      "            - 'right': bars are centered on the right bin edges.\n",
      "        \n",
      "        orientation : {'vertical', 'horizontal'}, default: 'vertical'\n",
      "            If 'horizontal', `~.Axes.barh` will be used for bar-type histograms\n",
      "            and the *bottom* kwarg will be the left edges.\n",
      "        \n",
      "        rwidth : float or None, default: None\n",
      "            The relative width of the bars as a fraction of the bin width.  If\n",
      "            ``None``, automatically compute the width.\n",
      "        \n",
      "            Ignored if *histtype* is 'step' or 'stepfilled'.\n",
      "        \n",
      "        log : bool, default: False\n",
      "            If ``True``, the histogram axis will be set to a log scale.\n",
      "        \n",
      "        color : color or array-like of colors or None, default: None\n",
      "            Color or sequence of colors, one per dataset.  Default (``None``)\n",
      "            uses the standard line color sequence.\n",
      "        \n",
      "        label : str or None, default: None\n",
      "            String, or sequence of strings to match multiple datasets.  Bar\n",
      "            charts yield multiple patches per dataset, but only the first gets\n",
      "            the label, so that `~.Axes.legend` will work as expected.\n",
      "        \n",
      "        stacked : bool, default: False\n",
      "            If ``True``, multiple data are stacked on top of each other If\n",
      "            ``False`` multiple data are arranged side by side if histtype is\n",
      "            'bar' or on top of each other if histtype is 'step'\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        n : array or list of arrays\n",
      "            The values of the histogram bins. See *density* and *weights* for a\n",
      "            description of the possible semantics.  If input *x* is an array,\n",
      "            then this is an array of length *nbins*. If input is a sequence of\n",
      "            arrays ``[data1, data2, ...]``, then this is a list of arrays with\n",
      "            the values of the histograms for each of the arrays in the same\n",
      "            order.  The dtype of the array *n* (or of its element arrays) will\n",
      "            always be float even if no weighting or normalization is used.\n",
      "        \n",
      "        bins : array\n",
      "            The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      "            edge of last bin).  Always a single array even when multiple data\n",
      "            sets are passed in.\n",
      "        \n",
      "        patches : `.BarContainer` or list of a single `.Polygon` or list of such objects\n",
      "            Container of individual artists used to create the histogram\n",
      "            or list of such containers if there are multiple input datasets.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            `~matplotlib.patches.Patch` properties\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        hist2d : 2D histograms\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For large numbers of bins (>1000), 'step' and 'stepfilled' can be\n",
      "        significantly faster than 'bar' and 'barstacked'.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *weights*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    hist2d(x, y, bins=10, range=None, density=False, weights=None, cmin=None, cmax=None, *, data=None, **kwargs)\n",
      "        Make a 2D histogram plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array-like, shape (n, )\n",
      "            Input values\n",
      "        \n",
      "        bins : None or int or [int, int] or array-like or [array, array]\n",
      "        \n",
      "            The bin specification:\n",
      "        \n",
      "            - If int, the number of bins for the two dimensions\n",
      "              (nx=ny=bins).\n",
      "            - If ``[int, int]``, the number of bins in each dimension\n",
      "              (nx, ny = bins).\n",
      "            - If array-like, the bin edges for the two dimensions\n",
      "              (x_edges=y_edges=bins).\n",
      "            - If ``[array, array]``, the bin edges in each dimension\n",
      "              (x_edges, y_edges = bins).\n",
      "        \n",
      "            The default value is 10.\n",
      "        \n",
      "        range : array-like shape(2, 2), optional\n",
      "            The leftmost and rightmost edges of the bins along each dimension\n",
      "            (if not specified explicitly in the bins parameters): ``[[xmin,\n",
      "            xmax], [ymin, ymax]]``. All values outside of this range will be\n",
      "            considered outliers and not tallied in the histogram.\n",
      "        \n",
      "        density : bool, default: False\n",
      "            Normalize histogram.  See the documentation for the *density*\n",
      "            parameter of `~.Axes.hist` for more details.\n",
      "        \n",
      "        weights : array-like, shape (n, ), optional\n",
      "            An array of values w_i weighing each sample (x_i, y_i).\n",
      "        \n",
      "        cmin, cmax : float, default: None\n",
      "            All bins that has count less than *cmin* or more than *cmax* will\n",
      "            not be displayed (set to NaN before passing to imshow) and these\n",
      "            count values in the return value count histogram will also be set\n",
      "            to nan upon return.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        h : 2D array\n",
      "            The bi-dimensional histogram of samples x and y. Values in x are\n",
      "            histogrammed along the first dimension and values in y are\n",
      "            histogrammed along the second dimension.\n",
      "        xedges : 1D array\n",
      "            The bin edges along the x axis.\n",
      "        yedges : 1D array\n",
      "            The bin edges along the y axis.\n",
      "        image : `~.matplotlib.collections.QuadMesh`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : Colormap or str, optional\n",
      "            A `.colors.Colormap` instance.  If not set, use rc settings.\n",
      "        \n",
      "        norm : Normalize, optional\n",
      "            A `.colors.Normalize` instance is used to\n",
      "            scale luminance data to ``[0, 1]``. If not set, defaults to\n",
      "            `.colors.Normalize()`.\n",
      "        \n",
      "        vmin/vmax : None or scalar, optional\n",
      "            Arguments passed to the `~.colors.Normalize` instance.\n",
      "        \n",
      "        alpha : ``0 <= scalar <= 1`` or ``None``, optional\n",
      "            The alpha blending value.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional parameters are passed along to the\n",
      "            `~.Axes.pcolormesh` method and `~matplotlib.collections.QuadMesh`\n",
      "            constructor.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        hist : 1D histogram plotting\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        - Currently ``hist2d`` calculates its own axis limits, and any limits\n",
      "          previously set are ignored.\n",
      "        - Rendering the histogram with a logarithmic color scale is\n",
      "          accomplished by passing a `.colors.LogNorm` instance to the *norm*\n",
      "          keyword argument. Likewise, power-law normalization (similar\n",
      "          in effect to gamma correction) can be accomplished with\n",
      "          `.colors.PowerNorm`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*, *weights*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    hlines(y, xmin, xmax, colors=None, linestyles='solid', label='', *, data=None, **kwargs)\n",
      "        Plot horizontal lines at each *y* from *xmin* to *xmax*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : float or array-like\n",
      "            y-indexes where to plot the lines.\n",
      "        \n",
      "        xmin, xmax : float or array-like\n",
      "            Respective beginning and end of each line. If scalars are\n",
      "            provided, all lines will have same length.\n",
      "        \n",
      "        colors : list of colors, default: :rc:`lines.color`\n",
      "        \n",
      "        linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      "        \n",
      "        label : str, default: ''\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.collections.LineCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :  `~matplotlib.collections.LineCollection` properties.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        vlines : vertical lines\n",
      "        axhline : horizontal line across the Axes\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *y*, *xmin*, *xmax*, *colors*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    hot()\n",
      "        Set the colormap to 'hot'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    hsv()\n",
      "        Set the colormap to 'hsv'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    imread(fname, format=None)\n",
      "        Read an image from a file into an array.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fname : str or file-like\n",
      "            The image file to read: a filename, a URL or a file-like object opened\n",
      "            in read-binary mode.\n",
      "        \n",
      "            Passing a URL is deprecated.  Please open the URL\n",
      "            for reading and pass the result to Pillow, e.g. with\n",
      "            ``PIL.Image.open(urllib.request.urlopen(url))``.\n",
      "        format : str, optional\n",
      "            The image file format assumed for reading the data. If not\n",
      "            given, the format is deduced from the filename.  If nothing can\n",
      "            be deduced, PNG is tried.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `numpy.array`\n",
      "            The image data. The returned array has shape\n",
      "        \n",
      "            - (M, N) for grayscale images.\n",
      "            - (M, N, 3) for RGB images.\n",
      "            - (M, N, 4) for RGBA images.\n",
      "    \n",
      "    imsave(fname, arr, **kwargs)\n",
      "        Save an array as an image file.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fname : str or path-like or file-like\n",
      "            A path or a file-like object to store the image in.\n",
      "            If *format* is not set, then the output format is inferred from the\n",
      "            extension of *fname*, if any, and from :rc:`savefig.format` otherwise.\n",
      "            If *format* is set, it determines the output format.\n",
      "        arr : array-like\n",
      "            The image data. The shape can be one of\n",
      "            MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA).\n",
      "        vmin, vmax : float, optional\n",
      "            *vmin* and *vmax* set the color scaling for the image by fixing the\n",
      "            values that map to the colormap color limits. If either *vmin*\n",
      "            or *vmax* is None, that limit is determined from the *arr*\n",
      "            min/max value.\n",
      "        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            A Colormap instance or registered colormap name. The colormap\n",
      "            maps scalar data to colors. It is ignored for RGB(A) data.\n",
      "        format : str, optional\n",
      "            The file format, e.g. 'png', 'pdf', 'svg', ...  The behavior when this\n",
      "            is unset is documented under *fname*.\n",
      "        origin : {'upper', 'lower'}, default: :rc:`image.origin`\n",
      "            Indicates whether the ``(0, 0)`` index of the array is in the upper\n",
      "            left or lower left corner of the axes.\n",
      "        dpi : float\n",
      "            The DPI to store in the metadata of the file.  This does not affect the\n",
      "            resolution of the output image.  Depending on file format, this may be\n",
      "            rounded to the nearest integer.\n",
      "        metadata : dict, optional\n",
      "            Metadata in the image file.  The supported keys depend on the output\n",
      "            format, see the documentation of the respective backends for more\n",
      "            information.\n",
      "        pil_kwargs : dict, optional\n",
      "            Keyword arguments passed to `PIL.Image.Image.save`.  If the 'pnginfo'\n",
      "            key is present, it completely overrides *metadata*, including the\n",
      "            default 'Software' key.\n",
      "    \n",
      "    imshow(X, cmap=None, norm=None, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, *, filternorm=True, filterrad=4.0, resample=None, url=None, data=None, **kwargs)\n",
      "        Display data as an image, i.e., on a 2D regular raster.\n",
      "        \n",
      "        The input may either be actual RGB(A) data, or 2D scalar data, which\n",
      "        will be rendered as a pseudocolor image. For displaying a grayscale\n",
      "        image set up the colormapping using the parameters\n",
      "        ``cmap='gray', vmin=0, vmax=255``.\n",
      "        \n",
      "        The number of pixels used to render an image is set by the Axes size\n",
      "        and the *dpi* of the figure. This can lead to aliasing artifacts when\n",
      "        the image is resampled because the displayed image size will usually\n",
      "        not match the size of *X* (see\n",
      "        :doc:`/gallery/images_contours_and_fields/image_antialiasing`).\n",
      "        The resampling can be controlled via the *interpolation* parameter\n",
      "        and/or :rc:`image.interpolation`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X : array-like or PIL image\n",
      "            The image data. Supported array shapes are:\n",
      "        \n",
      "            - (M, N): an image with scalar data. The values are mapped to\n",
      "              colors using normalization and a colormap. See parameters *norm*,\n",
      "              *cmap*, *vmin*, *vmax*.\n",
      "            - (M, N, 3): an image with RGB values (0-1 float or 0-255 int).\n",
      "            - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int),\n",
      "              i.e. including transparency.\n",
      "        \n",
      "            The first two dimensions (M, N) define the rows and columns of\n",
      "            the image.\n",
      "        \n",
      "            Out-of-range RGB(A) values are clipped.\n",
      "        \n",
      "        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            The Colormap instance or registered colormap name used to map\n",
      "            scalar data to colors. This parameter is ignored for RGB(A) data.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            The `.Normalize` instance used to scale scalar data to the [0, 1]\n",
      "            range before mapping to colors using *cmap*. By default, a linear\n",
      "            scaling mapping the lowest value to 0 and the highest to 1 is used.\n",
      "            This parameter is ignored for RGB(A) data.\n",
      "        \n",
      "        aspect : {'equal', 'auto'} or float, default: :rc:`image.aspect`\n",
      "            The aspect ratio of the Axes.  This parameter is particularly\n",
      "            relevant for images since it determines whether data pixels are\n",
      "            square.\n",
      "        \n",
      "            This parameter is a shortcut for explicitly calling\n",
      "            `.Axes.set_aspect`. See there for further details.\n",
      "        \n",
      "            - 'equal': Ensures an aspect ratio of 1. Pixels will be square\n",
      "              (unless pixel sizes are explicitly made non-square in data\n",
      "              coordinates using *extent*).\n",
      "            - 'auto': The Axes is kept fixed and the aspect is adjusted so\n",
      "              that the data fit in the Axes. In general, this will result in\n",
      "              non-square pixels.\n",
      "        \n",
      "        interpolation : str, default: :rc:`image.interpolation`\n",
      "            The interpolation method used.\n",
      "        \n",
      "            Supported values are 'none', 'antialiased', 'nearest', 'bilinear',\n",
      "            'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite',\n",
      "            'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell',\n",
      "            'sinc', 'lanczos', 'blackman'.\n",
      "        \n",
      "            If *interpolation* is 'none', then no interpolation is performed\n",
      "            on the Agg, ps, pdf and svg backends. Other backends will fall back\n",
      "            to 'nearest'. Note that most SVG renderers perform interpolation at\n",
      "            rendering and that the default interpolation method they implement\n",
      "            may differ.\n",
      "        \n",
      "            If *interpolation* is the default 'antialiased', then 'nearest'\n",
      "            interpolation is used if the image is upsampled by more than a\n",
      "            factor of three (i.e. the number of display pixels is at least\n",
      "            three times the size of the data array).  If the upsampling rate is\n",
      "            smaller than 3, or the image is downsampled, then 'hanning'\n",
      "            interpolation is used to act as an anti-aliasing filter, unless the\n",
      "            image happens to be upsampled by exactly a factor of two or one.\n",
      "        \n",
      "            See\n",
      "            :doc:`/gallery/images_contours_and_fields/interpolation_methods`\n",
      "            for an overview of the supported interpolation methods, and\n",
      "            :doc:`/gallery/images_contours_and_fields/image_antialiasing` for\n",
      "            a discussion of image antialiasing.\n",
      "        \n",
      "            Some interpolation methods require an additional radius parameter,\n",
      "            which can be set by *filterrad*. Additionally, the antigrain image\n",
      "            resize filter is controlled by the parameter *filternorm*.\n",
      "        \n",
      "        alpha : float or array-like, optional\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "            If *alpha* is an array, the alpha blending values are applied pixel\n",
      "            by pixel, and *alpha* must have the same shape as *X*.\n",
      "        \n",
      "        vmin, vmax : float, optional\n",
      "            When using scalar data and no explicit *norm*, *vmin* and *vmax*\n",
      "            define the data range that the colormap covers. By default,\n",
      "            the colormap covers the complete value range of the supplied\n",
      "            data. It is deprecated to use *vmin*/*vmax* when *norm* is given.\n",
      "            When using RGB(A) data, parameters *vmin*/*vmax* are ignored.\n",
      "        \n",
      "        origin : {'upper', 'lower'}, default: :rc:`image.origin`\n",
      "            Place the [0, 0] index of the array in the upper left or lower\n",
      "            left corner of the Axes. The convention (the default) 'upper' is\n",
      "            typically used for matrices and images.\n",
      "        \n",
      "            Note that the vertical axis points upward for 'lower'\n",
      "            but downward for 'upper'.\n",
      "        \n",
      "            See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for\n",
      "            examples and a more detailed description.\n",
      "        \n",
      "        extent : floats (left, right, bottom, top), optional\n",
      "            The bounding box in data coordinates that the image will fill.\n",
      "            The image is stretched individually along x and y to fill the box.\n",
      "        \n",
      "            The default extent is determined by the following conditions.\n",
      "            Pixels have unit size in data coordinates. Their centers are on\n",
      "            integer coordinates, and their center coordinates range from 0 to\n",
      "            columns-1 horizontally and from 0 to rows-1 vertically.\n",
      "        \n",
      "            Note that the direction of the vertical axis and thus the default\n",
      "            values for top and bottom depend on *origin*:\n",
      "        \n",
      "            - For ``origin == 'upper'`` the default is\n",
      "              ``(-0.5, numcols-0.5, numrows-0.5, -0.5)``.\n",
      "            - For ``origin == 'lower'`` the default is\n",
      "              ``(-0.5, numcols-0.5, -0.5, numrows-0.5)``.\n",
      "        \n",
      "            See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for\n",
      "            examples and a more detailed description.\n",
      "        \n",
      "        filternorm : bool, default: True\n",
      "            A parameter for the antigrain image resize filter (see the\n",
      "            antigrain documentation).  If *filternorm* is set, the filter\n",
      "            normalizes integer values and corrects the rounding errors. It\n",
      "            doesn't do anything with the source floating point values, it\n",
      "            corrects only integers according to the rule of 1.0 which means\n",
      "            that any sum of pixel weights must be equal to 1.0.  So, the\n",
      "            filter function must produce a graph of the proper shape.\n",
      "        \n",
      "        filterrad : float > 0, default: 4.0\n",
      "            The filter radius for filters that have a radius parameter, i.e.\n",
      "            when interpolation is one of: 'sinc', 'lanczos' or 'blackman'.\n",
      "        \n",
      "        resample : bool, default: :rc:`image.resample`\n",
      "            When *True*, use a full resampling method.  When *False*, only\n",
      "            resample when the output image is larger than the input image.\n",
      "        \n",
      "        url : str, optional\n",
      "            Set the url of the created `.AxesImage`. See `.Artist.set_url`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.image.AxesImage`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.artist.Artist` properties\n",
      "            These parameters are passed on to the constructor of the\n",
      "            `.AxesImage` artist.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matshow : Plot a matrix or an array as an image.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Unless *extent* is used, pixel centers will be located at integer\n",
      "        coordinates. In other words: the origin will coincide with the center\n",
      "        of pixel (0, 0).\n",
      "        \n",
      "        There are two common representations for RGB images with an alpha\n",
      "        channel:\n",
      "        \n",
      "        -   Straight (unassociated) alpha: R, G, and B channels represent the\n",
      "            color of the pixel, disregarding its opacity.\n",
      "        -   Premultiplied (associated) alpha: R, G, and B channels represent\n",
      "            the color of the pixel, adjusted for its opacity by multiplication.\n",
      "        \n",
      "        `~matplotlib.pyplot.imshow` expects RGB images adopting the straight\n",
      "        (unassociated) alpha representation.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    inferno()\n",
      "        Set the colormap to 'inferno'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    install_repl_displayhook()\n",
      "        Install a repl display hook so that any stale figure are automatically\n",
      "        redrawn when control is returned to the repl.\n",
      "        \n",
      "        This works both with IPython and with vanilla python shells.\n",
      "    \n",
      "    ioff()\n",
      "        Disable interactive mode.\n",
      "        \n",
      "        See `.pyplot.isinteractive` for more details.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ion : Enable interactive mode.\n",
      "        isinteractive : Whether interactive mode is enabled.\n",
      "        show : Show all figures (and maybe block).\n",
      "        pause : Show all figures, and block for a time.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For a temporary change, this can be used as a context manager::\n",
      "        \n",
      "            # if interactive mode is on\n",
      "            # then figures will be shown on creation\n",
      "            plt.ion()\n",
      "            # This figure will be shown immediately\n",
      "            fig = plt.figure()\n",
      "        \n",
      "            with plt.ioff():\n",
      "                # interactive mode will be off\n",
      "                # figures will not automatically be shown\n",
      "                fig2 = plt.figure()\n",
      "                # ...\n",
      "        \n",
      "        To enable usage as a context manager, this function returns an\n",
      "        ``_IoffContext`` object. The return value is not intended to be stored\n",
      "        or accessed by the user.\n",
      "    \n",
      "    ion()\n",
      "        Enable interactive mode.\n",
      "        \n",
      "        See `.pyplot.isinteractive` for more details.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ioff : Disable interactive mode.\n",
      "        isinteractive : Whether interactive mode is enabled.\n",
      "        show : Show all figures (and maybe block).\n",
      "        pause : Show all figures, and block for a time.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For a temporary change, this can be used as a context manager::\n",
      "        \n",
      "            # if interactive mode is off\n",
      "            # then figures will not be shown on creation\n",
      "            plt.ioff()\n",
      "            # This figure will not be shown immediately\n",
      "            fig = plt.figure()\n",
      "        \n",
      "            with plt.ion():\n",
      "                # interactive mode will be on\n",
      "                # figures will automatically be shown\n",
      "                fig2 = plt.figure()\n",
      "                # ...\n",
      "        \n",
      "        To enable usage as a context manager, this function returns an\n",
      "        ``_IonContext`` object. The return value is not intended to be stored\n",
      "        or accessed by the user.\n",
      "    \n",
      "    isinteractive()\n",
      "        Return whether plots are updated after every plotting command.\n",
      "        \n",
      "        The interactive mode is mainly useful if you build plots from the command\n",
      "        line and want to see the effect of each command while you are building the\n",
      "        figure.\n",
      "        \n",
      "        In interactive mode:\n",
      "        \n",
      "        - newly created figures will be shown immediately;\n",
      "        - figures will automatically redraw on change;\n",
      "        - `.pyplot.show` will not block by default.\n",
      "        \n",
      "        In non-interactive mode:\n",
      "        \n",
      "        - newly created figures and changes to figures will not be reflected until\n",
      "          explicitly asked to be;\n",
      "        - `.pyplot.show` will block by default.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ion : Enable interactive mode.\n",
      "        ioff : Disable interactive mode.\n",
      "        show : Show all figures (and maybe block).\n",
      "        pause : Show all figures, and block for a time.\n",
      "    \n",
      "    jet()\n",
      "        Set the colormap to 'jet'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    legend(*args, **kwargs)\n",
      "        Place a legend on the Axes.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            legend()\n",
      "            legend(labels)\n",
      "            legend(handles, labels)\n",
      "        \n",
      "        The call signatures correspond to these three different ways to use\n",
      "        this method:\n",
      "        \n",
      "        **1. Automatic detection of elements to be shown in the legend**\n",
      "        \n",
      "        The elements to be added to the legend are automatically determined,\n",
      "        when you do not pass in any extra arguments.\n",
      "        \n",
      "        In this case, the labels are taken from the artist. You can specify\n",
      "        them either at artist creation or by calling the\n",
      "        :meth:`~.Artist.set_label` method on the artist::\n",
      "        \n",
      "            ax.plot([1, 2, 3], label='Inline label')\n",
      "            ax.legend()\n",
      "        \n",
      "        or::\n",
      "        \n",
      "            line, = ax.plot([1, 2, 3])\n",
      "            line.set_label('Label via method')\n",
      "            ax.legend()\n",
      "        \n",
      "        Specific lines can be excluded from the automatic legend element\n",
      "        selection by defining a label starting with an underscore.\n",
      "        This is default for all artists, so calling `.Axes.legend` without\n",
      "        any arguments and without setting the labels manually will result in\n",
      "        no legend being drawn.\n",
      "        \n",
      "        \n",
      "        **2. Labeling existing plot elements**\n",
      "        \n",
      "        To make a legend for lines which already exist on the Axes\n",
      "        (via plot for instance), simply call this function with an iterable\n",
      "        of strings, one for each legend item. For example::\n",
      "        \n",
      "            ax.plot([1, 2, 3])\n",
      "            ax.legend(['A simple line'])\n",
      "        \n",
      "        Note: This call signature is discouraged, because the relation between\n",
      "        plot elements and labels is only implicit by their order and can\n",
      "        easily be mixed up.\n",
      "        \n",
      "        \n",
      "        **3. Explicitly defining the elements in the legend**\n",
      "        \n",
      "        For full control of which artists have a legend entry, it is possible\n",
      "        to pass an iterable of legend artists followed by an iterable of\n",
      "        legend labels respectively::\n",
      "        \n",
      "            ax.legend([line1, line2, line3], ['label1', 'label2', 'label3'])\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        handles : sequence of `.Artist`, optional\n",
      "            A list of Artists (lines, patches) to be added to the legend.\n",
      "            Use this together with *labels*, if you need full control on what\n",
      "            is shown in the legend and the automatic mechanism described above\n",
      "            is not sufficient.\n",
      "        \n",
      "            The length of handles and labels should be the same in this\n",
      "            case. If they are not, they are truncated to the smaller length.\n",
      "        \n",
      "        labels : list of str, optional\n",
      "            A list of labels to show next to the artists.\n",
      "            Use this together with *handles*, if you need full control on what\n",
      "            is shown in the legend and the automatic mechanism described above\n",
      "            is not sufficient.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.legend.Legend`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        loc : str or pair of floats, default: :rc:`legend.loc` ('best' for axes, 'upper right' for figures)\n",
      "            The location of the legend.\n",
      "        \n",
      "            The strings\n",
      "            ``'upper left', 'upper right', 'lower left', 'lower right'``\n",
      "            place the legend at the corresponding corner of the axes/figure.\n",
      "        \n",
      "            The strings\n",
      "            ``'upper center', 'lower center', 'center left', 'center right'``\n",
      "            place the legend at the center of the corresponding edge of the\n",
      "            axes/figure.\n",
      "        \n",
      "            The string ``'center'`` places the legend at the center of the axes/figure.\n",
      "        \n",
      "            The string ``'best'`` places the legend at the location, among the nine\n",
      "            locations defined so far, with the minimum overlap with other drawn\n",
      "            artists.  This option can be quite slow for plots with large amounts of\n",
      "            data; your plotting speed may benefit from providing a specific location.\n",
      "        \n",
      "            The location can also be a 2-tuple giving the coordinates of the lower-left\n",
      "            corner of the legend in axes coordinates (in which case *bbox_to_anchor*\n",
      "            will be ignored).\n",
      "        \n",
      "            For back-compatibility, ``'center right'`` (but no other location) can also\n",
      "            be spelled ``'right'``, and each \"string\" locations can also be given as a\n",
      "            numeric value:\n",
      "        \n",
      "                ===============   =============\n",
      "                Location String   Location Code\n",
      "                ===============   =============\n",
      "                'best'            0\n",
      "                'upper right'     1\n",
      "                'upper left'      2\n",
      "                'lower left'      3\n",
      "                'lower right'     4\n",
      "                'right'           5\n",
      "                'center left'     6\n",
      "                'center right'    7\n",
      "                'lower center'    8\n",
      "                'upper center'    9\n",
      "                'center'          10\n",
      "                ===============   =============\n",
      "        \n",
      "        bbox_to_anchor : `.BboxBase`, 2-tuple, or 4-tuple of floats\n",
      "            Box that is used to position the legend in conjunction with *loc*.\n",
      "            Defaults to `axes.bbox` (if called as a method to `.Axes.legend`) or\n",
      "            `figure.bbox` (if `.Figure.legend`).  This argument allows arbitrary\n",
      "            placement of the legend.\n",
      "        \n",
      "            Bbox coordinates are interpreted in the coordinate system given by\n",
      "            *bbox_transform*, with the default transform\n",
      "            Axes or Figure coordinates, depending on which ``legend`` is called.\n",
      "        \n",
      "            If a 4-tuple or `.BboxBase` is given, then it specifies the bbox\n",
      "            ``(x, y, width, height)`` that the legend is placed in.\n",
      "            To put the legend in the best location in the bottom right\n",
      "            quadrant of the axes (or figure)::\n",
      "        \n",
      "                loc='best', bbox_to_anchor=(0.5, 0., 0.5, 0.5)\n",
      "        \n",
      "            A 2-tuple ``(x, y)`` places the corner of the legend specified by *loc* at\n",
      "            x, y.  For example, to put the legend's upper right-hand corner in the\n",
      "            center of the axes (or figure) the following keywords can be used::\n",
      "        \n",
      "                loc='upper right', bbox_to_anchor=(0.5, 0.5)\n",
      "        \n",
      "        ncol : int, default: 1\n",
      "            The number of columns that the legend has.\n",
      "        \n",
      "        prop : None or `matplotlib.font_manager.FontProperties` or dict\n",
      "            The font properties of the legend. If None (default), the current\n",
      "            :data:`matplotlib.rcParams` will be used.\n",
      "        \n",
      "        fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "            The font size of the legend. If the value is numeric the size will be the\n",
      "            absolute font size in points. String values are relative to the current\n",
      "            default font size. This argument is only used if *prop* is not specified.\n",
      "        \n",
      "        labelcolor : str or list\n",
      "            The color of the text in the legend. Either a valid color string\n",
      "            (for example, 'red'), or a list of color strings. The labelcolor can\n",
      "            also be made to match the color of the line or marker using 'linecolor',\n",
      "            'markerfacecolor' (or 'mfc'), or 'markeredgecolor' (or 'mec').\n",
      "        \n",
      "        numpoints : int, default: :rc:`legend.numpoints`\n",
      "            The number of marker points in the legend when creating a legend\n",
      "            entry for a `.Line2D` (line).\n",
      "        \n",
      "        scatterpoints : int, default: :rc:`legend.scatterpoints`\n",
      "            The number of marker points in the legend when creating\n",
      "            a legend entry for a `.PathCollection` (scatter plot).\n",
      "        \n",
      "        scatteryoffsets : iterable of floats, default: ``[0.375, 0.5, 0.3125]``\n",
      "            The vertical offset (relative to the font size) for the markers\n",
      "            created for a scatter plot legend entry. 0.0 is at the base the\n",
      "            legend text, and 1.0 is at the top. To draw all markers at the\n",
      "            same height, set to ``[0.5]``.\n",
      "        \n",
      "        markerscale : float, default: :rc:`legend.markerscale`\n",
      "            The relative size of legend markers compared with the originally\n",
      "            drawn ones.\n",
      "        \n",
      "        markerfirst : bool, default: True\n",
      "            If *True*, legend marker is placed to the left of the legend label.\n",
      "            If *False*, legend marker is placed to the right of the legend label.\n",
      "        \n",
      "        frameon : bool, default: :rc:`legend.frameon`\n",
      "            Whether the legend should be drawn on a patch (frame).\n",
      "        \n",
      "        fancybox : bool, default: :rc:`legend.fancybox`\n",
      "            Whether round edges should be enabled around the `~.FancyBboxPatch` which\n",
      "            makes up the legend's background.\n",
      "        \n",
      "        shadow : bool, default: :rc:`legend.shadow`\n",
      "            Whether to draw a shadow behind the legend.\n",
      "        \n",
      "        framealpha : float, default: :rc:`legend.framealpha`\n",
      "            The alpha transparency of the legend's background.\n",
      "            If *shadow* is activated and *framealpha* is ``None``, the default value is\n",
      "            ignored.\n",
      "        \n",
      "        facecolor : \"inherit\" or color, default: :rc:`legend.facecolor`\n",
      "            The legend's background color.\n",
      "            If ``\"inherit\"``, use :rc:`axes.facecolor`.\n",
      "        \n",
      "        edgecolor : \"inherit\" or color, default: :rc:`legend.edgecolor`\n",
      "            The legend's background patch edge color.\n",
      "            If ``\"inherit\"``, use take :rc:`axes.edgecolor`.\n",
      "        \n",
      "        mode : {\"expand\", None}\n",
      "            If *mode* is set to ``\"expand\"`` the legend will be horizontally\n",
      "            expanded to fill the axes area (or *bbox_to_anchor* if defines\n",
      "            the legend's size).\n",
      "        \n",
      "        bbox_transform : None or `matplotlib.transforms.Transform`\n",
      "            The transform for the bounding box (*bbox_to_anchor*). For a value\n",
      "            of ``None`` (default) the Axes'\n",
      "            :data:`~matplotlib.axes.Axes.transAxes` transform will be used.\n",
      "        \n",
      "        title : str or None\n",
      "            The legend's title. Default is no title (``None``).\n",
      "        \n",
      "        title_fontsize : int or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: :rc:`legend.title_fontsize`\n",
      "            The font size of the legend's title.\n",
      "        \n",
      "        borderpad : float, default: :rc:`legend.borderpad`\n",
      "            The fractional whitespace inside the legend border, in font-size units.\n",
      "        \n",
      "        labelspacing : float, default: :rc:`legend.labelspacing`\n",
      "            The vertical space between the legend entries, in font-size units.\n",
      "        \n",
      "        handlelength : float, default: :rc:`legend.handlelength`\n",
      "            The length of the legend handles, in font-size units.\n",
      "        \n",
      "        handletextpad : float, default: :rc:`legend.handletextpad`\n",
      "            The pad between the legend handle and text, in font-size units.\n",
      "        \n",
      "        borderaxespad : float, default: :rc:`legend.borderaxespad`\n",
      "            The pad between the axes and legend border, in font-size units.\n",
      "        \n",
      "        columnspacing : float, default: :rc:`legend.columnspacing`\n",
      "            The spacing between columns, in font-size units.\n",
      "        \n",
      "        handler_map : dict or None\n",
      "            The custom dictionary mapping instances or types to a legend\n",
      "            handler. This *handler_map* updates the default handler map\n",
      "            found at `matplotlib.legend.Legend.get_legend_handler_map`.\n",
      "        \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .Figure.legend\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Some artists are not supported by this function.  See\n",
      "        :doc:`/tutorials/intermediate/legend_guide` for details.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        .. plot:: gallery/text_labels_and_annotations/legend.py\n",
      "    \n",
      "    locator_params(axis='both', tight=None, **kwargs)\n",
      "        Control behavior of major tick locators.\n",
      "        \n",
      "        Because the locator is involved in autoscaling, `~.Axes.autoscale_view`\n",
      "        is called automatically after the parameters are changed.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        axis : {'both', 'x', 'y'}, default: 'both'\n",
      "            The axis on which to operate.\n",
      "        \n",
      "        tight : bool or None, optional\n",
      "            Parameter passed to `~.Axes.autoscale_view`.\n",
      "            Default is None, for no change.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Remaining keyword arguments are passed to directly to the\n",
      "            ``set_params()`` method of the locator. Supported keywords depend\n",
      "            on the type of the locator. See for example\n",
      "            `~.ticker.MaxNLocator.set_params` for the `.ticker.MaxNLocator`\n",
      "            used by default for linear axes.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        When plotting small subplots, one might want to reduce the maximum\n",
      "        number of ticks and use tight bounds, for example::\n",
      "        \n",
      "            ax.locator_params(tight=True, nbins=4)\n",
      "    \n",
      "    loglog(*args, **kwargs)\n",
      "        Make a plot with log scaling on both the x and y axis.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            loglog([x], y, [fmt], data=None, **kwargs)\n",
      "            loglog([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      "        \n",
      "        This is just a thin wrapper around `.plot` which additionally changes\n",
      "        both the x-axis and the y-axis to log scaling. All of the concepts and\n",
      "        parameters of plot can be used here as well.\n",
      "        \n",
      "        The additional parameters *base*, *subs* and *nonpositive* control the\n",
      "        x/y-axis properties. They are just forwarded to `.Axes.set_xscale` and\n",
      "        `.Axes.set_yscale`. To use different properties on the x-axis and the\n",
      "        y-axis, use e.g.\n",
      "        ``ax.set_xscale(\"log\", base=10); ax.set_yscale(\"log\", base=2)``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        base : float, default: 10\n",
      "            Base of the logarithm.\n",
      "        \n",
      "        subs : sequence, optional\n",
      "            The location of the minor ticks. If *None*, reasonable locations\n",
      "            are automatically chosen depending on the number of decades in the\n",
      "            plot. See `.Axes.set_xscale`/`.Axes.set_yscale` for details.\n",
      "        \n",
      "        nonpositive : {'mask', 'clip'}, default: 'mask'\n",
      "            Non-positive values can be masked as invalid, or clipped to a very\n",
      "            small positive number.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `~.Line2D`\n",
      "            Objects representing the plotted data.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All parameters supported by `.plot`.\n",
      "    \n",
      "    magma()\n",
      "        Set the colormap to 'magma'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    magnitude_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, *, data=None, **kwargs)\n",
      "        Plot the magnitude spectrum.\n",
      "        \n",
      "        Compute the magnitude spectrum of *x*.  Data is padded to a\n",
      "        length of *pad_to* and the windowing function *window* is applied to\n",
      "        the signal.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data.\n",
      "        \n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  While not increasing the actual resolution of the spectrum (the\n",
      "            minimum distance between resolvable peaks), this can give more points in\n",
      "            the plot, allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft().  The default is None, which sets *pad_to* equal to\n",
      "            the length of the input signal (i.e. no padding).\n",
      "        \n",
      "        scale : {'default', 'linear', 'dB'}\n",
      "            The scaling of the values in the *spec*.  'linear' is no scaling.\n",
      "            'dB' returns the values in dB scale, i.e., the dB amplitude\n",
      "            (20 * log10). 'default' is 'linear'.\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 1-D array\n",
      "            The values for the magnitude spectrum before scaling (real valued).\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *spectrum*.\n",
      "        \n",
      "        line : `~matplotlib.lines.Line2D`\n",
      "            The line created by this function.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        psd\n",
      "            Plots the power spectral density.\n",
      "        angle_spectrum\n",
      "            Plots the angles of the corresponding frequencies.\n",
      "        phase_spectrum\n",
      "            Plots the phase (unwrapped angle) of the corresponding frequencies.\n",
      "        specgram\n",
      "            Can plot the magnitude spectrum of segments within the signal in a\n",
      "            colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    margins(*margins, x=None, y=None, tight=True)\n",
      "        Set or retrieve autoscaling margins.\n",
      "        \n",
      "        The padding added to each limit of the axes is the *margin*\n",
      "        times the data interval. All input parameters must be floats\n",
      "        within the range [0, 1]. Passing both positional and keyword\n",
      "        arguments is invalid and will raise a TypeError. If no\n",
      "        arguments (positional or otherwise) are provided, the current\n",
      "        margins will remain in place and simply be returned.\n",
      "        \n",
      "        Specifying any margin changes only the autoscaling; for example,\n",
      "        if *xmargin* is not None, then *xmargin* times the X data\n",
      "        interval will be added to each end of that interval before\n",
      "        it is used in autoscaling.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        *margins : float, optional\n",
      "            If a single positional argument is provided, it specifies\n",
      "            both margins of the x-axis and y-axis limits. If two\n",
      "            positional arguments are provided, they will be interpreted\n",
      "            as *xmargin*, *ymargin*. If setting the margin on a single\n",
      "            axis is desired, use the keyword arguments described below.\n",
      "        \n",
      "        x, y : float, optional\n",
      "            Specific margin values for the x-axis and y-axis,\n",
      "            respectively. These cannot be used with positional\n",
      "            arguments, but can be used individually to alter on e.g.,\n",
      "            only the y-axis.\n",
      "        \n",
      "        tight : bool or None, default: True\n",
      "            The *tight* parameter is passed to :meth:`autoscale_view`,\n",
      "            which is executed after a margin is changed; the default\n",
      "            here is *True*, on the assumption that when margins are\n",
      "            specified, no additional padding to match tick marks is\n",
      "            usually desired.  Set *tight* to *None* will preserve\n",
      "            the previous setting.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xmargin, ymargin : float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If a previously used Axes method such as :meth:`pcolor` has set\n",
      "        :attr:`use_sticky_edges` to `True`, only the limits not set by\n",
      "        the \"sticky artists\" will be modified. To force all of the\n",
      "        margins to be set, set :attr:`use_sticky_edges` to `False`\n",
      "        before calling :meth:`margins`.\n",
      "    \n",
      "    matshow(A, fignum=None, **kwargs)\n",
      "        Display an array as a matrix in a new figure window.\n",
      "        \n",
      "        The origin is set at the upper left hand corner and rows (first\n",
      "        dimension of the array) are displayed horizontally.  The aspect\n",
      "        ratio of the figure window is that of the array, unless this would\n",
      "        make an excessively short or narrow figure.\n",
      "        \n",
      "        Tick labels for the xaxis are placed on top.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        A : 2D array-like\n",
      "            The matrix to be displayed.\n",
      "        \n",
      "        fignum : None or int or False\n",
      "            If *None*, create a new figure window with automatic numbering.\n",
      "        \n",
      "            If a nonzero integer, draw into the figure with the given number\n",
      "            (create it if it does not exist).\n",
      "        \n",
      "            If 0, use the current axes (or create one if it does not exist).\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "               Because of how `.Axes.matshow` tries to set the figure aspect\n",
      "               ratio to be the one of the array, strange things may happen if you\n",
      "               reuse an existing figure.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.image.AxesImage`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.axes.Axes.imshow` arguments\n",
      "    \n",
      "    minorticks_off()\n",
      "        Remove minor ticks from the axes.\n",
      "    \n",
      "    minorticks_on()\n",
      "        Display minor ticks on the axes.\n",
      "        \n",
      "        Displaying minor ticks may reduce performance; you may turn them off\n",
      "        using `minorticks_off()` if drawing speed is a problem.\n",
      "    \n",
      "    new_figure_manager(num, *args, **kwargs)\n",
      "        Create a new figure manager instance.\n",
      "    \n",
      "    nipy_spectral()\n",
      "        Set the colormap to 'nipy_spectral'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    pause(interval)\n",
      "        Run the GUI event loop for *interval* seconds.\n",
      "        \n",
      "        If there is an active figure, it will be updated and displayed before the\n",
      "        pause, and the GUI event loop (if any) will run during the pause.\n",
      "        \n",
      "        This can be used for crude animation.  For more complex animation use\n",
      "        :mod:`matplotlib.animation`.\n",
      "        \n",
      "        If there is no active figure, sleep for *interval* seconds instead.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.animation : Proper animations\n",
      "        show : Show all figures and optional block until all figures are closed.\n",
      "    \n",
      "    pcolor(*args, shading=None, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, data=None, **kwargs)\n",
      "        Create a pseudocolor plot with a non-regular rectangular grid.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            pcolor([X, Y,] C, **kwargs)\n",
      "        \n",
      "        *X* and *Y* can be used to specify the corners of the quadrilaterals.\n",
      "        \n",
      "        .. hint::\n",
      "        \n",
      "            ``pcolor()`` can be very slow for large arrays. In most\n",
      "            cases you should use the similar but much faster\n",
      "            `~.Axes.pcolormesh` instead. See\n",
      "            :ref:`Differences between pcolor() and pcolormesh()\n",
      "            <differences-pcolor-pcolormesh>` for a discussion of the\n",
      "            differences.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        C : 2D array-like\n",
      "            The color-mapped values.\n",
      "        \n",
      "        X, Y : array-like, optional\n",
      "            The coordinates of the corners of quadrilaterals of a pcolormesh::\n",
      "        \n",
      "                (X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])\n",
      "                                      +-----+\n",
      "                                      |     |\n",
      "                                      +-----+\n",
      "                    (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])\n",
      "        \n",
      "            Note that the column index corresponds to the x-coordinate, and\n",
      "            the row index corresponds to y. For details, see the\n",
      "            :ref:`Notes <axes-pcolormesh-grid-orientation>` section below.\n",
      "        \n",
      "            If ``shading='flat'`` the dimensions of *X* and *Y* should be one\n",
      "            greater than those of *C*, and the quadrilateral is colored due\n",
      "            to the value at ``C[i, j]``.  If *X*, *Y* and *C* have equal\n",
      "            dimensions, a warning will be raised and the last row and column\n",
      "            of *C* will be ignored.\n",
      "        \n",
      "            If ``shading='nearest'``, the dimensions of *X* and *Y* should be\n",
      "            the same as those of *C* (if not, a ValueError will be raised). The\n",
      "            color ``C[i, j]`` will be centered on ``(X[i, j], Y[i, j])``.\n",
      "        \n",
      "            If *X* and/or *Y* are 1-D arrays or column vectors they will be\n",
      "            expanded as needed into the appropriate 2D arrays, making a\n",
      "            rectangular grid.\n",
      "        \n",
      "        shading : {'flat', 'nearest', 'auto'}, optional\n",
      "            The fill style for the quadrilateral; defaults to 'flat' or\n",
      "            :rc:`pcolor.shading`. Possible values:\n",
      "        \n",
      "            - 'flat': A solid color is used for each quad. The color of the\n",
      "              quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by\n",
      "              ``C[i, j]``. The dimensions of *X* and *Y* should be\n",
      "              one greater than those of *C*; if they are the same as *C*,\n",
      "              then a deprecation warning is raised, and the last row\n",
      "              and column of *C* are dropped.\n",
      "            - 'nearest': Each grid point will have a color centered on it,\n",
      "              extending halfway between the adjacent grid centers.  The\n",
      "              dimensions of *X* and *Y* must be the same as *C*.\n",
      "            - 'auto': Choose 'flat' if dimensions of *X* and *Y* are one\n",
      "              larger than *C*.  Choose 'nearest' if dimensions are the same.\n",
      "        \n",
      "            See :doc:`/gallery/images_contours_and_fields/pcolormesh_grids`\n",
      "            for more description.\n",
      "        \n",
      "        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            A Colormap instance or registered colormap name. The colormap\n",
      "            maps the *C* values to colors.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            The Normalize instance scales the data values to the canonical\n",
      "            colormap range [0, 1] for mapping to colors. By default, the data\n",
      "            range is mapped to the colorbar range using linear scaling.\n",
      "        \n",
      "        vmin, vmax : float, default: None\n",
      "            The colorbar range. If *None*, suitable min/max values are\n",
      "            automatically chosen by the `~.Normalize` instance (defaults to\n",
      "            the respective min/max values of *C* in case of the default linear\n",
      "            scaling).\n",
      "            It is deprecated to use *vmin*/*vmax* when *norm* is given.\n",
      "        \n",
      "        edgecolors : {'none', None, 'face', color, color sequence}, optional\n",
      "            The color of the edges. Defaults to 'none'. Possible values:\n",
      "        \n",
      "            - 'none' or '': No edge.\n",
      "            - *None*: :rc:`patch.edgecolor` will be used. Note that currently\n",
      "              :rc:`patch.force_edgecolor` has to be True for this to work.\n",
      "            - 'face': Use the adjacent face color.\n",
      "            - A color or sequence of colors will set the edge color.\n",
      "        \n",
      "            The singular form *edgecolor* works as an alias.\n",
      "        \n",
      "        alpha : float, default: None\n",
      "            The alpha blending value of the face color, between 0 (transparent)\n",
      "            and 1 (opaque). Note: The edgecolor is currently not affected by\n",
      "            this.\n",
      "        \n",
      "        snap : bool, default: False\n",
      "            Whether to snap the mesh to pixel boundaries.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `matplotlib.collections.Collection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        antialiaseds : bool, default: False\n",
      "            The default *antialiaseds* is False if the default\n",
      "            *edgecolors*\\ =\"none\" is used.  This eliminates artificial lines\n",
      "            at patch boundaries, and works regardless of the value of alpha.\n",
      "            If *edgecolors* is not \"none\", then the default *antialiaseds*\n",
      "            is taken from :rc:`patch.antialiased`.\n",
      "            Stroking the edges may be preferred if *alpha* is 1, but will\n",
      "            cause artifacts otherwise.\n",
      "        \n",
      "        **kwargs\n",
      "            Additionally, the following arguments are allowed. They are passed\n",
      "            along to the `~matplotlib.collections.PolyCollection` constructor:\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        pcolormesh : for an explanation of the differences between\n",
      "            pcolor and pcolormesh.\n",
      "        imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a\n",
      "            faster alternative.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        **Masked arrays**\n",
      "        \n",
      "        *X*, *Y* and *C* may be masked arrays. If either ``C[i, j]``, or one\n",
      "        of the vertices surrounding ``C[i, j]`` (*X* or *Y* at\n",
      "        ``[i, j], [i+1, j], [i, j+1], [i+1, j+1]``) is masked, nothing is\n",
      "        plotted.\n",
      "        \n",
      "        .. _axes-pcolor-grid-orientation:\n",
      "        \n",
      "        **Grid orientation**\n",
      "        \n",
      "        The grid orientation follows the standard matrix convention: An array\n",
      "        *C* with shape (nrows, ncolumns) is plotted with the column number as\n",
      "        *X* and the row number as *Y*.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    pcolormesh(*args, alpha=None, norm=None, cmap=None, vmin=None, vmax=None, shading=None, antialiased=False, data=None, **kwargs)\n",
      "        Create a pseudocolor plot with a non-regular rectangular grid.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            pcolormesh([X, Y,] C, **kwargs)\n",
      "        \n",
      "        *X* and *Y* can be used to specify the corners of the quadrilaterals.\n",
      "        \n",
      "        .. hint::\n",
      "        \n",
      "           `~.Axes.pcolormesh` is similar to `~.Axes.pcolor`. It is much faster\n",
      "           and preferred in most cases. For a detailed discussion on the\n",
      "           differences see :ref:`Differences between pcolor() and pcolormesh()\n",
      "           <differences-pcolor-pcolormesh>`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        C : 2D array-like\n",
      "            The color-mapped values.\n",
      "        \n",
      "        X, Y : array-like, optional\n",
      "            The coordinates of the corners of quadrilaterals of a pcolormesh::\n",
      "        \n",
      "                (X[i+1, j], Y[i+1, j])       (X[i+1, j+1], Y[i+1, j+1])\n",
      "                                      +-----+\n",
      "                                      |     |\n",
      "                                      +-----+\n",
      "                    (X[i, j], Y[i, j])       (X[i, j+1], Y[i, j+1])\n",
      "        \n",
      "            Note that the column index corresponds to the x-coordinate, and\n",
      "            the row index corresponds to y. For details, see the\n",
      "            :ref:`Notes <axes-pcolormesh-grid-orientation>` section below.\n",
      "        \n",
      "            If ``shading='flat'`` the dimensions of *X* and *Y* should be one\n",
      "            greater than those of *C*, and the quadrilateral is colored due\n",
      "            to the value at ``C[i, j]``.  If *X*, *Y* and *C* have equal\n",
      "            dimensions, a warning will be raised and the last row and column\n",
      "            of *C* will be ignored.\n",
      "        \n",
      "            If ``shading='nearest'`` or ``'gouraud'``, the dimensions of *X*\n",
      "            and *Y* should be the same as those of *C* (if not, a ValueError\n",
      "            will be raised).  For ``'nearest'`` the color ``C[i, j]`` is\n",
      "            centered on ``(X[i, j], Y[i, j])``.  For ``'gouraud'``, a smooth\n",
      "            interpolation is caried out between the quadrilateral corners.\n",
      "        \n",
      "            If *X* and/or *Y* are 1-D arrays or column vectors they will be\n",
      "            expanded as needed into the appropriate 2D arrays, making a\n",
      "            rectangular grid.\n",
      "        \n",
      "        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            A Colormap instance or registered colormap name. The colormap\n",
      "            maps the *C* values to colors.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            The Normalize instance scales the data values to the canonical\n",
      "            colormap range [0, 1] for mapping to colors. By default, the data\n",
      "            range is mapped to the colorbar range using linear scaling.\n",
      "        \n",
      "        vmin, vmax : float, default: None\n",
      "            The colorbar range. If *None*, suitable min/max values are\n",
      "            automatically chosen by the `~.Normalize` instance (defaults to\n",
      "            the respective min/max values of *C* in case of the default linear\n",
      "            scaling).\n",
      "            It is deprecated to use *vmin*/*vmax* when *norm* is given.\n",
      "        \n",
      "        edgecolors : {'none', None, 'face', color, color sequence}, optional\n",
      "            The color of the edges. Defaults to 'none'. Possible values:\n",
      "        \n",
      "            - 'none' or '': No edge.\n",
      "            - *None*: :rc:`patch.edgecolor` will be used. Note that currently\n",
      "              :rc:`patch.force_edgecolor` has to be True for this to work.\n",
      "            - 'face': Use the adjacent face color.\n",
      "            - A color or sequence of colors will set the edge color.\n",
      "        \n",
      "            The singular form *edgecolor* works as an alias.\n",
      "        \n",
      "        alpha : float, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        shading : {'flat', 'nearest', 'gouraud', 'auto'}, optional\n",
      "            The fill style for the quadrilateral; defaults to\n",
      "            'flat' or :rc:`pcolor.shading`. Possible values:\n",
      "        \n",
      "            - 'flat': A solid color is used for each quad. The color of the\n",
      "              quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by\n",
      "              ``C[i, j]``. The dimensions of *X* and *Y* should be\n",
      "              one greater than those of *C*; if they are the same as *C*,\n",
      "              then a deprecation warning is raised, and the last row\n",
      "              and column of *C* are dropped.\n",
      "            - 'nearest': Each grid point will have a color centered on it,\n",
      "              extending halfway between the adjacent grid centers.  The\n",
      "              dimensions of *X* and *Y* must be the same as *C*.\n",
      "            - 'gouraud': Each quad will be Gouraud shaded: The color of the\n",
      "              corners (i', j') are given by ``C[i', j']``. The color values of\n",
      "              the area in between is interpolated from the corner values.\n",
      "              The dimensions of *X* and *Y* must be the same as *C*. When\n",
      "              Gouraud shading is used, *edgecolors* is ignored.\n",
      "            - 'auto': Choose 'flat' if dimensions of *X* and *Y* are one\n",
      "              larger than *C*.  Choose 'nearest' if dimensions are the same.\n",
      "        \n",
      "            See :doc:`/gallery/images_contours_and_fields/pcolormesh_grids`\n",
      "            for more description.\n",
      "        \n",
      "        snap : bool, default: False\n",
      "            Whether to snap the mesh to pixel boundaries.\n",
      "        \n",
      "        rasterized: bool, optional\n",
      "            Rasterize the pcolormesh when drawing vector graphics.  This can\n",
      "            speed up rendering and produce smaller files for large data sets.\n",
      "            See also :doc:`/gallery/misc/rasterization_demo`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `matplotlib.collections.QuadMesh`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Additionally, the following arguments are allowed. They are passed\n",
      "            along to the `~matplotlib.collections.QuadMesh` constructor:\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        pcolor : An alternative implementation with slightly different\n",
      "            features. For a detailed discussion on the differences see\n",
      "            :ref:`Differences between pcolor() and pcolormesh()\n",
      "            <differences-pcolor-pcolormesh>`.\n",
      "        imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a\n",
      "            faster alternative.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        **Masked arrays**\n",
      "        \n",
      "        *C* may be a masked array. If ``C[i, j]`` is masked, the corresponding\n",
      "        quadrilateral will be transparent. Masking of *X* and *Y* is not\n",
      "        supported. Use `~.Axes.pcolor` if you need this functionality.\n",
      "        \n",
      "        .. _axes-pcolormesh-grid-orientation:\n",
      "        \n",
      "        **Grid orientation**\n",
      "        \n",
      "        The grid orientation follows the standard matrix convention: An array\n",
      "        *C* with shape (nrows, ncolumns) is plotted with the column number as\n",
      "        *X* and the row number as *Y*.\n",
      "        \n",
      "        .. _differences-pcolor-pcolormesh:\n",
      "        \n",
      "        **Differences between pcolor() and pcolormesh()**\n",
      "        \n",
      "        Both methods are used to create a pseudocolor plot of a 2D array\n",
      "        using quadrilaterals.\n",
      "        \n",
      "        The main difference lies in the created object and internal data\n",
      "        handling:\n",
      "        While `~.Axes.pcolor` returns a `.PolyCollection`, `~.Axes.pcolormesh`\n",
      "        returns a `.QuadMesh`. The latter is more specialized for the given\n",
      "        purpose and thus is faster. It should almost always be preferred.\n",
      "        \n",
      "        There is also a slight difference in the handling of masked arrays.\n",
      "        Both `~.Axes.pcolor` and `~.Axes.pcolormesh` support masked arrays\n",
      "        for *C*. However, only `~.Axes.pcolor` supports masked arrays for *X*\n",
      "        and *Y*. The reason lies in the internal handling of the masked values.\n",
      "        `~.Axes.pcolor` leaves out the respective polygons from the\n",
      "        PolyCollection. `~.Axes.pcolormesh` sets the facecolor of the masked\n",
      "        elements to transparent. You can see the difference when using\n",
      "        edgecolors. While all edges are drawn irrespective of masking in a\n",
      "        QuadMesh, the edge between two adjacent masked quadrilaterals in\n",
      "        `~.Axes.pcolor` is not drawn as the corresponding polygons do not\n",
      "        exist in the PolyCollection.\n",
      "        \n",
      "        Another difference is the support of Gouraud shading in\n",
      "        `~.Axes.pcolormesh`, which is not available with `~.Axes.pcolor`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    phase_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, *, data=None, **kwargs)\n",
      "        Plot the phase spectrum.\n",
      "        \n",
      "        Compute the phase spectrum (unwrapped angle spectrum) of *x*.\n",
      "        Data is padded to a length of *pad_to* and the windowing function\n",
      "        *window* is applied to the signal.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data\n",
      "        \n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  While not increasing the actual resolution of the spectrum (the\n",
      "            minimum distance between resolvable peaks), this can give more points in\n",
      "            the plot, allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft().  The default is None, which sets *pad_to* equal to\n",
      "            the length of the input signal (i.e. no padding).\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 1-D array\n",
      "            The values for the phase spectrum in radians (real valued).\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *spectrum*.\n",
      "        \n",
      "        line : `~matplotlib.lines.Line2D`\n",
      "            The line created by this function.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        magnitude_spectrum\n",
      "            Plots the magnitudes of the corresponding frequencies.\n",
      "        angle_spectrum\n",
      "            Plots the wrapped version of this function.\n",
      "        specgram\n",
      "            Can plot the phase spectrum of segments within the signal in a\n",
      "            colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=0, radius=1, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, *, normalize=None, data=None)\n",
      "        Plot a pie chart.\n",
      "        \n",
      "        Make a pie chart of array *x*.  The fractional area of each wedge is\n",
      "        given by ``x/sum(x)``.  If ``sum(x) < 1``, then the values of *x* give\n",
      "        the fractional area directly and the array will not be normalized. The\n",
      "        resulting pie will have an empty wedge of size ``1 - sum(x)``.\n",
      "        \n",
      "        The wedges are plotted counterclockwise, by default starting from the\n",
      "        x-axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1D array-like\n",
      "            The wedge sizes.\n",
      "        \n",
      "        explode : array-like, default: None\n",
      "            If not *None*, is a ``len(x)`` array which specifies the fraction\n",
      "            of the radius with which to offset each wedge.\n",
      "        \n",
      "        labels : list, default: None\n",
      "            A sequence of strings providing the labels for each wedge\n",
      "        \n",
      "        colors : array-like, default: None\n",
      "            A sequence of colors through which the pie chart will cycle.  If\n",
      "            *None*, will use the colors in the currently active cycle.\n",
      "        \n",
      "        autopct : None or str or callable, default: None\n",
      "            If not *None*, is a string or function used to label the wedges\n",
      "            with their numeric value.  The label will be placed inside the\n",
      "            wedge.  If it is a format string, the label will be ``fmt % pct``.\n",
      "            If it is a function, it will be called.\n",
      "        \n",
      "        pctdistance : float, default: 0.6\n",
      "            The ratio between the center of each pie slice and the start of\n",
      "            the text generated by *autopct*.  Ignored if *autopct* is *None*.\n",
      "        \n",
      "        shadow : bool, default: False\n",
      "            Draw a shadow beneath the pie.\n",
      "        \n",
      "        normalize : None or bool, default: None\n",
      "            When *True*, always make a full pie by normalizing x so that\n",
      "            ``sum(x) == 1``. *False* makes a partial pie if ``sum(x) <= 1``\n",
      "            and raises a `ValueError` for ``sum(x) > 1``.\n",
      "        \n",
      "            When *None*, defaults to *True* if ``sum(x) >= 1`` and *False* if\n",
      "            ``sum(x) < 1``.\n",
      "        \n",
      "            Please note that the previous default value of *None* is now\n",
      "            deprecated, and the default will change to *True* in the next\n",
      "            release. Please pass ``normalize=False`` explicitly if you want to\n",
      "            draw a partial pie.\n",
      "        \n",
      "        labeldistance : float or None, default: 1.1\n",
      "            The radial distance at which the pie labels are drawn.\n",
      "            If set to ``None``, label are not drawn, but are stored for use in\n",
      "            ``legend()``\n",
      "        \n",
      "        startangle : float, default: 0 degrees\n",
      "            The angle by which the start of the pie is rotated,\n",
      "            counterclockwise from the x-axis.\n",
      "        \n",
      "        radius : float, default: 1\n",
      "            The radius of the pie.\n",
      "        \n",
      "        counterclock : bool, default: True\n",
      "            Specify fractions direction, clockwise or counterclockwise.\n",
      "        \n",
      "        wedgeprops : dict, default: None\n",
      "            Dict of arguments passed to the wedge objects making the pie.\n",
      "            For example, you can pass in ``wedgeprops = {'linewidth': 3}``\n",
      "            to set the width of the wedge border lines equal to 3.\n",
      "            For more details, look at the doc/arguments of the wedge object.\n",
      "            By default ``clip_on=False``.\n",
      "        \n",
      "        textprops : dict, default: None\n",
      "            Dict of arguments to pass to the text objects.\n",
      "        \n",
      "        center : (float, float), default: (0, 0)\n",
      "            The coordinates of the center of the chart.\n",
      "        \n",
      "        frame : bool, default: False\n",
      "            Plot Axes frame with the chart if true.\n",
      "        \n",
      "        rotatelabels : bool, default: False\n",
      "            Rotate each label to the angle of the corresponding slice if true.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        patches : list\n",
      "            A sequence of `matplotlib.patches.Wedge` instances\n",
      "        \n",
      "        texts : list\n",
      "            A list of the label `.Text` instances.\n",
      "        \n",
      "        autotexts : list\n",
      "            A list of `.Text` instances for the numeric labels. This will only\n",
      "            be returned if the parameter *autopct* is not *None*.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The pie chart will probably look best if the figure and Axes are\n",
      "        square, or the Axes aspect is equal.\n",
      "        This method sets the aspect ratio of the axis to \"equal\".\n",
      "        The Axes aspect ratio can be controlled with `.Axes.set_aspect`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *explode*, *labels*, *colors*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    pink()\n",
      "        Set the colormap to 'pink'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    plasma()\n",
      "        Set the colormap to 'plasma'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    plot(*args, scalex=True, scaley=True, data=None, **kwargs)\n",
      "        Plot y versus x as lines and/or markers.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            plot([x], y, [fmt], *, data=None, **kwargs)\n",
      "            plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      "        \n",
      "        The coordinates of the points or line nodes are given by *x*, *y*.\n",
      "        \n",
      "        The optional parameter *fmt* is a convenient way for defining basic\n",
      "        formatting like color, marker and linestyle. It's a shortcut string\n",
      "        notation described in the *Notes* section below.\n",
      "        \n",
      "        >>> plot(x, y)        # plot x and y using default line style and color\n",
      "        >>> plot(x, y, 'bo')  # plot x and y using blue circle markers\n",
      "        >>> plot(y)           # plot y using x as index array 0..N-1\n",
      "        >>> plot(y, 'r+')     # ditto, but with red plusses\n",
      "        \n",
      "        You can use `.Line2D` properties as keyword arguments for more\n",
      "        control on the appearance. Line properties and *fmt* can be mixed.\n",
      "        The following two calls yield identical results:\n",
      "        \n",
      "        >>> plot(x, y, 'go--', linewidth=2, markersize=12)\n",
      "        >>> plot(x, y, color='green', marker='o', linestyle='dashed',\n",
      "        ...      linewidth=2, markersize=12)\n",
      "        \n",
      "        When conflicting with *fmt*, keyword arguments take precedence.\n",
      "        \n",
      "        \n",
      "        **Plotting labelled data**\n",
      "        \n",
      "        There's a convenient way for plotting objects with labelled data (i.e.\n",
      "        data that can be accessed by index ``obj['y']``). Instead of giving\n",
      "        the data in *x* and *y*, you can provide the object in the *data*\n",
      "        parameter and just give the labels for *x* and *y*::\n",
      "        \n",
      "        >>> plot('xlabel', 'ylabel', data=obj)\n",
      "        \n",
      "        All indexable objects are supported. This could e.g. be a `dict`, a\n",
      "        `pandas.DataFrame` or a structured numpy array.\n",
      "        \n",
      "        \n",
      "        **Plotting multiple sets of data**\n",
      "        \n",
      "        There are various ways to plot multiple sets of data.\n",
      "        \n",
      "        - The most straight forward way is just to call `plot` multiple times.\n",
      "          Example:\n",
      "        \n",
      "          >>> plot(x1, y1, 'bo')\n",
      "          >>> plot(x2, y2, 'go')\n",
      "        \n",
      "        - If *x* and/or *y* are 2D arrays a separate data set will be drawn\n",
      "          for every column. If both *x* and *y* are 2D, they must have the\n",
      "          same shape. If only one of them is 2D with shape (N, m) the other\n",
      "          must have length N and will be used for every data set m.\n",
      "        \n",
      "          Example:\n",
      "        \n",
      "          >>> x = [1, 2, 3]\n",
      "          >>> y = np.array([[1, 2], [3, 4], [5, 6]])\n",
      "          >>> plot(x, y)\n",
      "        \n",
      "          is equivalent to:\n",
      "        \n",
      "          >>> for col in range(y.shape[1]):\n",
      "          ...     plot(x, y[:, col])\n",
      "        \n",
      "        - The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*\n",
      "          groups::\n",
      "        \n",
      "          >>> plot(x1, y1, 'g^', x2, y2, 'g-')\n",
      "        \n",
      "          In this case, any additional keyword argument applies to all\n",
      "          datasets. Also this syntax cannot be combined with the *data*\n",
      "          parameter.\n",
      "        \n",
      "        By default, each line is assigned a different style specified by a\n",
      "        'style cycle'. The *fmt* and line property parameters are only\n",
      "        necessary if you want explicit deviations from these defaults.\n",
      "        Alternatively, you can also change the style cycle using\n",
      "        :rc:`axes.prop_cycle`.\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array-like or scalar\n",
      "            The horizontal / vertical coordinates of the data points.\n",
      "            *x* values are optional and default to ``range(len(y))``.\n",
      "        \n",
      "            Commonly, these parameters are 1D arrays.\n",
      "        \n",
      "            They can also be scalars, or two-dimensional (in that case, the\n",
      "            columns represent separate data sets).\n",
      "        \n",
      "            These arguments cannot be passed as keywords.\n",
      "        \n",
      "        fmt : str, optional\n",
      "            A format string, e.g. 'ro' for red circles. See the *Notes*\n",
      "            section for a full description of the format strings.\n",
      "        \n",
      "            Format strings are just an abbreviation for quickly setting\n",
      "            basic line properties. All of these and more can also be\n",
      "            controlled by keyword arguments.\n",
      "        \n",
      "            This argument cannot be passed as keyword.\n",
      "        \n",
      "        data : indexable object, optional\n",
      "            An object with labelled data. If given, provide the label names to\n",
      "            plot in *x* and *y*.\n",
      "        \n",
      "            .. note::\n",
      "                Technically there's a slight ambiguity in calls where the\n",
      "                second label is a valid *fmt*. ``plot('n', 'o', data=obj)``\n",
      "                could be ``plt(x, y)`` or ``plt(y, fmt)``. In such cases,\n",
      "                the former interpretation is chosen, but a warning is issued.\n",
      "                You may suppress the warning by adding an empty format string\n",
      "                ``plot('n', 'o', '', data=obj)``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `.Line2D`\n",
      "            A list of lines representing the plotted data.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        scalex, scaley : bool, default: True\n",
      "            These parameters determine if the view limits are adapted to the\n",
      "            data limits. The values are passed on to `autoscale_view`.\n",
      "        \n",
      "        **kwargs : `.Line2D` properties, optional\n",
      "            *kwargs* are used to specify properties like a line label (for\n",
      "            auto legends), linewidth, antialiasing, marker face color.\n",
      "            Example::\n",
      "        \n",
      "            >>> plot([1, 2, 3], [1, 2, 3], 'go-', label='line 1', linewidth=2)\n",
      "            >>> plot([1, 2, 3], [1, 4, 9], 'rs', label='line 2')\n",
      "        \n",
      "            If you specify multiple lines with one plot call, the kwargs apply\n",
      "            to all those lines. In case the label object is iterable, each\n",
      "            element is used as labels for each set of data.\n",
      "        \n",
      "            Here is a list of available `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scatter : XY scatter plot with markers of varying size and/or color (\n",
      "            sometimes also called bubble chart).\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        **Format Strings**\n",
      "        \n",
      "        A format string consists of a part for color, marker and line::\n",
      "        \n",
      "            fmt = '[marker][line][color]'\n",
      "        \n",
      "        Each of them is optional. If not provided, the value from the style\n",
      "        cycle is used. Exception: If ``line`` is given, but no ``marker``,\n",
      "        the data will be a line without markers.\n",
      "        \n",
      "        Other combinations such as ``[color][marker][line]`` are also\n",
      "        supported, but note that their parsing may be ambiguous.\n",
      "        \n",
      "        **Markers**\n",
      "        \n",
      "        =============   ===============================\n",
      "        character       description\n",
      "        =============   ===============================\n",
      "        ``'.'``         point marker\n",
      "        ``','``         pixel marker\n",
      "        ``'o'``         circle marker\n",
      "        ``'v'``         triangle_down marker\n",
      "        ``'^'``         triangle_up marker\n",
      "        ``'<'``         triangle_left marker\n",
      "        ``'>'``         triangle_right marker\n",
      "        ``'1'``         tri_down marker\n",
      "        ``'2'``         tri_up marker\n",
      "        ``'3'``         tri_left marker\n",
      "        ``'4'``         tri_right marker\n",
      "        ``'8'``         octagon marker\n",
      "        ``'s'``         square marker\n",
      "        ``'p'``         pentagon marker\n",
      "        ``'P'``         plus (filled) marker\n",
      "        ``'*'``         star marker\n",
      "        ``'h'``         hexagon1 marker\n",
      "        ``'H'``         hexagon2 marker\n",
      "        ``'+'``         plus marker\n",
      "        ``'x'``         x marker\n",
      "        ``'X'``         x (filled) marker\n",
      "        ``'D'``         diamond marker\n",
      "        ``'d'``         thin_diamond marker\n",
      "        ``'|'``         vline marker\n",
      "        ``'_'``         hline marker\n",
      "        =============   ===============================\n",
      "        \n",
      "        **Line Styles**\n",
      "        \n",
      "        =============    ===============================\n",
      "        character        description\n",
      "        =============    ===============================\n",
      "        ``'-'``          solid line style\n",
      "        ``'--'``         dashed line style\n",
      "        ``'-.'``         dash-dot line style\n",
      "        ``':'``          dotted line style\n",
      "        =============    ===============================\n",
      "        \n",
      "        Example format strings::\n",
      "        \n",
      "            'b'    # blue markers with default shape\n",
      "            'or'   # red circles\n",
      "            '-g'   # green solid line\n",
      "            '--'   # dashed line with default color\n",
      "            '^k:'  # black triangle_up markers connected by a dotted line\n",
      "        \n",
      "        **Colors**\n",
      "        \n",
      "        The supported color abbreviations are the single letter codes\n",
      "        \n",
      "        =============    ===============================\n",
      "        character        color\n",
      "        =============    ===============================\n",
      "        ``'b'``          blue\n",
      "        ``'g'``          green\n",
      "        ``'r'``          red\n",
      "        ``'c'``          cyan\n",
      "        ``'m'``          magenta\n",
      "        ``'y'``          yellow\n",
      "        ``'k'``          black\n",
      "        ``'w'``          white\n",
      "        =============    ===============================\n",
      "        \n",
      "        and the ``'CN'`` colors that index into the default property cycle.\n",
      "        \n",
      "        If the color is the only part of the format string, you can\n",
      "        additionally use any  `matplotlib.colors` spec, e.g. full names\n",
      "        (``'green'``) or hex strings (``'#008000'``).\n",
      "    \n",
      "    plot_date(x, y, fmt='o', tz=None, xdate=True, ydate=False, *, data=None, **kwargs)\n",
      "        Plot co-ercing the axis to treat floats as dates.\n",
      "        \n",
      "        Similar to `.plot`, this plots *y* vs. *x* as lines or markers.\n",
      "        However, the axis labels are formatted as dates depending on *xdate*\n",
      "        and *ydate*.  Note that `.plot` will work with `datetime` and\n",
      "        `numpy.datetime64` objects without resorting to this method.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array-like\n",
      "            The coordinates of the data points. If *xdate* or *ydate* is\n",
      "            *True*, the respective values *x* or *y* are interpreted as\n",
      "            :ref:`Matplotlib dates <date-format>`.\n",
      "        \n",
      "        fmt : str, optional\n",
      "            The plot format string. For details, see the corresponding\n",
      "            parameter in `.plot`.\n",
      "        \n",
      "        tz : timezone string or `datetime.tzinfo`, default: :rc:`timezone`\n",
      "            The time zone to use in labeling dates.\n",
      "        \n",
      "        xdate : bool, default: True\n",
      "            If *True*, the *x*-axis will be interpreted as Matplotlib dates.\n",
      "        \n",
      "        ydate : bool, default: False\n",
      "            If *True*, the *y*-axis will be interpreted as Matplotlib dates.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `~.Line2D`\n",
      "            Objects representing the plotted data.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.dates : Helper functions on dates.\n",
      "        matplotlib.dates.date2num : Convert dates to num.\n",
      "        matplotlib.dates.num2date : Convert num to dates.\n",
      "        matplotlib.dates.drange : Create an equally spaced sequence of dates.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If you are using custom date tickers and formatters, it may be\n",
      "        necessary to set the formatters/locators after the call to\n",
      "        `.plot_date`. `.plot_date` will set the default tick locator to\n",
      "        `.AutoDateLocator` (if the tick locator is not already set to a\n",
      "        `.DateLocator` instance) and the default tick formatter to\n",
      "        `.AutoDateFormatter` (if the tick formatter is not already set to a\n",
      "        `.DateFormatter` instance).\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    plotting()\n",
      "        ============================ ====================================================================================================================\n",
      "        Function                     Description                                                                                                         \n",
      "        ============================ ====================================================================================================================\n",
      "        `acorr`                      Plot the autocorrelation of *x*.                                                                                    \n",
      "        `angle_spectrum`             Plot the angle spectrum.                                                                                            \n",
      "        `annotate`                   Annotate the point *xy* with text *text*.                                                                           \n",
      "        `arrow`                      Add an arrow to the Axes.                                                                                           \n",
      "        `autoscale`                  Autoscale the axis view to the data (toggle).                                                                       \n",
      "        `axes`                       Add an axes to the current figure and make it the current axes.                                                     \n",
      "        `axhline`                    Add a horizontal line across the axis.                                                                              \n",
      "        `axhspan`                    Add a horizontal span (rectangle) across the Axes.                                                                  \n",
      "        `axis`                       Convenience method to get or set some axis properties.                                                              \n",
      "        `axline`                     Add an infinitely long straight line.                                                                               \n",
      "        `axvline`                    Add a vertical line across the Axes.                                                                                \n",
      "        `axvspan`                    Add a vertical span (rectangle) across the Axes.                                                                    \n",
      "        `bar`                        Make a bar plot.                                                                                                    \n",
      "        `bar_label`                  Label a bar plot.                                                                                                   \n",
      "        `barbs`                      Plot a 2D field of barbs.                                                                                           \n",
      "        `barh`                       Make a horizontal bar plot.                                                                                         \n",
      "        `box`                        Turn the axes box on or off on the current axes.                                                                    \n",
      "        `boxplot`                    Make a box and whisker plot.                                                                                        \n",
      "        `broken_barh`                Plot a horizontal sequence of rectangles.                                                                           \n",
      "        `cla`                        Clear the current axes.                                                                                             \n",
      "        `clabel`                     Label a contour plot.                                                                                               \n",
      "        `clf`                        Clear the current figure.                                                                                           \n",
      "        `clim`                       Set the color limits of the current image.                                                                          \n",
      "        `close`                      Close a figure window.                                                                                              \n",
      "        `cohere`                     Plot the coherence between *x* and *y*.                                                                             \n",
      "        `colorbar`                   Add a colorbar to a plot.                                                                                           \n",
      "        `contour`                    Plot contour lines.                                                                                                 \n",
      "        `contourf`                   Plot filled contours.                                                                                               \n",
      "        `csd`                        Plot the cross-spectral density.                                                                                    \n",
      "        `delaxes`                    Remove an `~.axes.Axes` (defaulting to the current axes) from its figure.                                           \n",
      "        `draw`                       Redraw the current figure.                                                                                          \n",
      "        `errorbar`                   Plot y versus x as lines and/or markers with attached errorbars.                                                    \n",
      "        `eventplot`                  Plot identical parallel lines at the given positions.                                                               \n",
      "        `figimage`                   Add a non-resampled image to the figure.                                                                            \n",
      "        `figlegend`                  Place a legend on the figure.                                                                                       \n",
      "        `fignum_exists`              Return whether the figure with the given id exists.                                                                 \n",
      "        `figtext`                    Add text to figure.                                                                                                 \n",
      "        `figure`                     Create a new figure, or activate an existing figure.                                                                \n",
      "        `fill`                       Plot filled polygons.                                                                                               \n",
      "        `fill_between`               Fill the area between two horizontal curves.                                                                        \n",
      "        `fill_betweenx`              Fill the area between two vertical curves.                                                                          \n",
      "        `findobj`                    Find artist objects.                                                                                                \n",
      "        `gca`                        Get the current Axes, creating one if necessary.                                                                    \n",
      "        `gcf`                        Get the current figure.                                                                                             \n",
      "        `gci`                        Get the current colorable artist.                                                                                   \n",
      "        `get`                        Return the value of an `.Artist`'s *property*, or print all of them.                                                \n",
      "        `get_figlabels`              Return a list of existing figure labels.                                                                            \n",
      "        `get_fignums`                Return a list of existing figure numbers.                                                                           \n",
      "        `getp`                       Return the value of an `.Artist`'s *property*, or print all of them.                                                \n",
      "        `grid`                       Configure the grid lines.                                                                                           \n",
      "        `hexbin`                     Make a 2D hexagonal binning plot of points *x*, *y*.                                                                \n",
      "        `hist`                       Plot a histogram.                                                                                                   \n",
      "        `hist2d`                     Make a 2D histogram plot.                                                                                           \n",
      "        `hlines`                     Plot horizontal lines at each *y* from *xmin* to *xmax*.                                                            \n",
      "        `imread`                     Read an image from a file into an array.                                                                            \n",
      "        `imsave`                     Save an array as an image file.                                                                                     \n",
      "        `imshow`                     Display data as an image, i.e., on a 2D regular raster.                                                             \n",
      "        `install_repl_displayhook`   Install a repl display hook so that any stale figure are automatically redrawn when control is returned to the repl.\n",
      "        `ioff`                       Disable interactive mode.                                                                                           \n",
      "        `ion`                        Enable interactive mode.                                                                                            \n",
      "        `isinteractive`              Return whether plots are updated after every plotting command.                                                      \n",
      "        `legend`                     Place a legend on the Axes.                                                                                         \n",
      "        `locator_params`             Control behavior of major tick locators.                                                                            \n",
      "        `loglog`                     Make a plot with log scaling on both the x and y axis.                                                              \n",
      "        `magnitude_spectrum`         Plot the magnitude spectrum.                                                                                        \n",
      "        `margins`                    Set or retrieve autoscaling margins.                                                                                \n",
      "        `matshow`                    Display an array as a matrix in a new figure window.                                                                \n",
      "        `minorticks_off`             Remove minor ticks from the axes.                                                                                   \n",
      "        `minorticks_on`              Display minor ticks on the axes.                                                                                    \n",
      "        `new_figure_manager`         Create a new figure manager instance.                                                                               \n",
      "        `pause`                      Run the GUI event loop for *interval* seconds.                                                                      \n",
      "        `pcolor`                     Create a pseudocolor plot with a non-regular rectangular grid.                                                      \n",
      "        `pcolormesh`                 Create a pseudocolor plot with a non-regular rectangular grid.                                                      \n",
      "        `phase_spectrum`             Plot the phase spectrum.                                                                                            \n",
      "        `pie`                        Plot a pie chart.                                                                                                   \n",
      "        `plot`                       Plot y versus x as lines and/or markers.                                                                            \n",
      "        `plot_date`                  Plot co-ercing the axis to treat floats as dates.                                                                   \n",
      "        `polar`                      Make a polar plot.                                                                                                  \n",
      "        `psd`                        Plot the power spectral density.                                                                                    \n",
      "        `quiver`                     Plot a 2D field of arrows.                                                                                          \n",
      "        `quiverkey`                  Add a key to a quiver plot.                                                                                         \n",
      "        `rc`                         Set the current `.rcParams`.                                                                                        \n",
      "        `rc_context`                 Return a context manager for temporarily changing rcParams.                                                         \n",
      "        `rcdefaults`                 Restore the `.rcParams` from Matplotlib's internal default style.                                                   \n",
      "        `rgrids`                     Get or set the radial gridlines on the current polar plot.                                                          \n",
      "        `savefig`                    Save the current figure.                                                                                            \n",
      "        `sca`                        Set the current Axes to *ax* and the current Figure to the parent of *ax*.                                          \n",
      "        `scatter`                    A scatter plot of *y* vs.                                                                                           \n",
      "        `sci`                        Set the current image.                                                                                              \n",
      "        `semilogx`                   Make a plot with log scaling on the x axis.                                                                         \n",
      "        `semilogy`                   Make a plot with log scaling on the y axis.                                                                         \n",
      "        `set_cmap`                   Set the default colormap, and applies it to the current image if any.                                               \n",
      "        `setp`                       Set one or more properties on an `.Artist`, or list allowed values.                                                 \n",
      "        `show`                       Display all open figures.                                                                                           \n",
      "        `specgram`                   Plot a spectrogram.                                                                                                 \n",
      "        `spy`                        Plot the sparsity pattern of a 2D array.                                                                            \n",
      "        `stackplot`                  Draw a stacked area plot.                                                                                           \n",
      "        `stairs`                     A stepwise constant function as a line with bounding edges or a filled plot.                                        \n",
      "        `stem`                       Create a stem plot.                                                                                                 \n",
      "        `step`                       Make a step plot.                                                                                                   \n",
      "        `streamplot`                 Draw streamlines of a vector flow.                                                                                  \n",
      "        `subplot`                    Add an Axes to the current figure or retrieve an existing Axes.                                                     \n",
      "        `subplot2grid`               Create a subplot at a specific location inside a regular grid.                                                      \n",
      "        `subplot_mosaic`             Build a layout of Axes based on ASCII art or nested lists.                                                          \n",
      "        `subplot_tool`               Launch a subplot tool window for a figure.                                                                          \n",
      "        `subplots`                   Create a figure and a set of subplots.                                                                              \n",
      "        `subplots_adjust`            Adjust the subplot layout parameters.                                                                               \n",
      "        `suptitle`                   Add a centered suptitle to the figure.                                                                              \n",
      "        `switch_backend`             Close all open figures and set the Matplotlib backend.                                                              \n",
      "        `table`                      Add a table to an `~.axes.Axes`.                                                                                    \n",
      "        `text`                       Add text to the Axes.                                                                                               \n",
      "        `thetagrids`                 Get or set the theta gridlines on the current polar plot.                                                           \n",
      "        `tick_params`                Change the appearance of ticks, tick labels, and gridlines.                                                         \n",
      "        `ticklabel_format`           Configure the `.ScalarFormatter` used by default for linear axes.                                                   \n",
      "        `tight_layout`               Adjust the padding between and around subplots.                                                                     \n",
      "        `title`                      Set a title for the Axes.                                                                                           \n",
      "        `tricontour`                 Draw contour lines on an unstructured triangular grid.                                                              \n",
      "        `tricontourf`                Draw contour regions on an unstructured triangular grid.                                                            \n",
      "        `tripcolor`                  Create a pseudocolor plot of an unstructured triangular grid.                                                       \n",
      "        `triplot`                    Draw a unstructured triangular grid as lines and/or markers.                                                        \n",
      "        `twinx`                      Make and return a second axes that shares the *x*-axis.                                                             \n",
      "        `twiny`                      Make and return a second axes that shares the *y*-axis.                                                             \n",
      "        `uninstall_repl_displayhook` Uninstall the matplotlib display hook.                                                                              \n",
      "        `violinplot`                 Make a violin plot.                                                                                                 \n",
      "        `vlines`                     Plot vertical lines at each *x* from *ymin* to *ymax*.                                                              \n",
      "        `xcorr`                      Plot the cross correlation between *x* and *y*.                                                                     \n",
      "        `xkcd`                       Turn on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.                                                      \n",
      "        `xlabel`                     Set the label for the x-axis.                                                                                       \n",
      "        `xlim`                       Get or set the x limits of the current axes.                                                                        \n",
      "        `xscale`                     Set the x-axis scale.                                                                                               \n",
      "        `xticks`                     Get or set the current tick locations and labels of the x-axis.                                                     \n",
      "        `ylabel`                     Set the label for the y-axis.                                                                                       \n",
      "        `ylim`                       Get or set the y-limits of the current axes.                                                                        \n",
      "        `yscale`                     Set the y-axis scale.                                                                                               \n",
      "        `yticks`                     Get or set the current tick locations and labels of the y-axis.                                                     \n",
      "        ============================ ====================================================================================================================\n",
      "    \n",
      "    polar(*args, **kwargs)\n",
      "        Make a polar plot.\n",
      "        \n",
      "        call signature::\n",
      "        \n",
      "          polar(theta, r, **kwargs)\n",
      "        \n",
      "        Multiple *theta*, *r* arguments are supported, with format strings, as in\n",
      "        `plot`.\n",
      "    \n",
      "    prism()\n",
      "        Set the colormap to 'prism'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    psd(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, *, data=None, **kwargs)\n",
      "        Plot the power spectral density.\n",
      "        \n",
      "        The power spectral density :math:`P_{xx}` by Welch's average\n",
      "        periodogram method.  The vector *x* is divided into *NFFT* length\n",
      "        segments.  Each segment is detrended by function *detrend* and\n",
      "        windowed by function *window*.  *noverlap* gives the length of\n",
      "        the overlap between segments.  The :math:`|\\mathrm{fft}(i)|^2`\n",
      "        of each segment :math:`i` are averaged to compute :math:`P_{xx}`,\n",
      "        with a scaling to correct for power loss due to windowing.\n",
      "        \n",
      "        If len(*x*) < *NFFT*, it will be zero padded to *NFFT*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data\n",
      "        \n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  This can be different from *NFFT*, which specifies the number\n",
      "            of data points used.  While not increasing the actual resolution of the\n",
      "            spectrum (the minimum distance between resolvable peaks), this can give\n",
      "            more points in the plot, allowing for more detail. This corresponds to\n",
      "            the *n* parameter in the call to fft(). The default is None, which sets\n",
      "            *pad_to* equal to *NFFT*\n",
      "        \n",
      "        NFFT : int, default: 256\n",
      "            The number of data points used in each block for the FFT.  A power 2 is\n",
      "            most efficient.  This should *NOT* be used to get zero padding, or the\n",
      "            scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      "            The function applied to each segment before fft-ing, designed to remove\n",
      "            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      "            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`\n",
      "            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      "            but you can use a custom function as well.  You can also use a string to\n",
      "            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      "            `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      "        \n",
      "        scale_by_freq : bool, default: True\n",
      "            Whether the resulting density values should be scaled by the scaling\n",
      "            frequency, which gives density in units of Hz^-1.  This allows for\n",
      "            integration over the returned frequency values.  The default is True for\n",
      "            MATLAB compatibility.\n",
      "        \n",
      "        noverlap : int, default: 0 (no overlap)\n",
      "            The number of points of overlap between segments.\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        return_line : bool, default: False\n",
      "            Whether to include the line object plotted in the returned values.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Pxx : 1-D array\n",
      "            The values for the power spectrum :math:`P_{xx}` before scaling\n",
      "            (real valued).\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *Pxx*.\n",
      "        \n",
      "        line : `~matplotlib.lines.Line2D`\n",
      "            The line created by this function.\n",
      "            Only returned if *return_line* is True.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the `.Line2D` properties:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        specgram\n",
      "            Differs in the default overlap; in not returning the mean of the\n",
      "            segment periodograms; in returning the times of the segments; and\n",
      "            in plotting a colormap instead of a line.\n",
      "        magnitude_spectrum\n",
      "            Plots the magnitude spectrum.\n",
      "        csd\n",
      "            Plots the spectral density between two signals.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For plotting, the power is plotted as\n",
      "        :math:`10\\log_{10}(P_{xx})` for decibels, though *Pxx* itself\n",
      "        is returned.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      "        John Wiley & Sons (1986)\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    quiver(*args, data=None, **kw)\n",
      "        Plot a 2D field of arrows.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          quiver([X, Y], U, V, [C], **kw)\n",
      "        \n",
      "        *X*, *Y* define the arrow locations, *U*, *V* define the arrow directions, and\n",
      "        *C* optionally sets the color.\n",
      "        \n",
      "        **Arrow size**\n",
      "        \n",
      "        The default settings auto-scales the length of the arrows to a reasonable size.\n",
      "        To change this behavior see the *scale* and *scale_units* parameters.\n",
      "        \n",
      "        **Arrow shape**\n",
      "        \n",
      "        The defaults give a slightly swept-back arrow; to make the head a\n",
      "        triangle, make *headaxislength* the same as *headlength*. To make the\n",
      "        arrow more pointed, reduce *headwidth* or increase *headlength* and\n",
      "        *headaxislength*. To make the head smaller relative to the shaft,\n",
      "        scale down all the head parameters. You will probably do best to leave\n",
      "        minshaft alone.\n",
      "        \n",
      "        **Arrow outline**\n",
      "        \n",
      "        *linewidths* and *edgecolors* can be used to customize the arrow\n",
      "        outlines.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X, Y : 1D or 2D array-like, optional\n",
      "            The x and y coordinates of the arrow locations.\n",
      "        \n",
      "            If not given, they will be generated as a uniform integer meshgrid based\n",
      "            on the dimensions of *U* and *V*.\n",
      "        \n",
      "            If *X* and *Y* are 1D but *U*, *V* are 2D, *X*, *Y* are expanded to 2D\n",
      "            using ``X, Y = np.meshgrid(X, Y)``. In this case ``len(X)`` and ``len(Y)``\n",
      "            must match the column and row dimensions of *U* and *V*.\n",
      "        \n",
      "        U, V : 1D or 2D array-like\n",
      "            The x and y direction components of the arrow vectors.\n",
      "        \n",
      "            They must have the same number of elements, matching the number of arrow\n",
      "            locations. *U* and *V* may be masked. Only locations unmasked in\n",
      "            *U*, *V*, and *C* will be drawn.\n",
      "        \n",
      "        C : 1D or 2D array-like, optional\n",
      "            Numeric data that defines the arrow colors by colormapping via *norm* and\n",
      "            *cmap*.\n",
      "        \n",
      "            This does not support explicit colors. If you want to set colors directly,\n",
      "            use *color* instead.  The size of *C* must match the number of arrow\n",
      "            locations.\n",
      "        \n",
      "        units : {'width', 'height', 'dots', 'inches', 'x', 'y', 'xy'}, default: 'width'\n",
      "            The arrow dimensions (except for *length*) are measured in multiples of\n",
      "            this unit.\n",
      "        \n",
      "            The following values are supported:\n",
      "        \n",
      "            - 'width', 'height': The width or height of the axis.\n",
      "            - 'dots', 'inches': Pixels or inches based on the figure dpi.\n",
      "            - 'x', 'y', 'xy': *X*, *Y* or :math:`\\sqrt{X^2 + Y^2}` in data units.\n",
      "        \n",
      "            The arrows scale differently depending on the units.  For\n",
      "            'x' or 'y', the arrows get larger as one zooms in; for other\n",
      "            units, the arrow size is independent of the zoom state.  For\n",
      "            'width or 'height', the arrow size increases with the width and\n",
      "            height of the axes, respectively, when the window is resized;\n",
      "            for 'dots' or 'inches', resizing does not change the arrows.\n",
      "        \n",
      "        angles : {'uv', 'xy'} or array-like, default: 'uv'\n",
      "            Method for determining the angle of the arrows.\n",
      "        \n",
      "            - 'uv': The arrow axis aspect ratio is 1 so that\n",
      "              if *U* == *V* the orientation of the arrow on the plot is 45 degrees\n",
      "              counter-clockwise from the horizontal axis (positive to the right).\n",
      "        \n",
      "              Use this if the arrows symbolize a quantity that is not based on\n",
      "              *X*, *Y* data coordinates.\n",
      "        \n",
      "            - 'xy': Arrows point from (x, y) to (x+u, y+v).\n",
      "              Use this for plotting a gradient field, for example.\n",
      "        \n",
      "            - Alternatively, arbitrary angles may be specified explicitly as an array\n",
      "              of values in degrees, counter-clockwise from the horizontal axis.\n",
      "        \n",
      "              In this case *U*, *V* is only used to determine the length of the\n",
      "              arrows.\n",
      "        \n",
      "            Note: inverting a data axis will correspondingly invert the\n",
      "            arrows only with ``angles='xy'``.\n",
      "        \n",
      "        scale : float, optional\n",
      "            Number of data units per arrow length unit, e.g., m/s per plot width; a\n",
      "            smaller scale parameter makes the arrow longer. Default is *None*.\n",
      "        \n",
      "            If *None*, a simple autoscaling algorithm is used, based on the average\n",
      "            vector length and the number of vectors. The arrow length unit is given by\n",
      "            the *scale_units* parameter.\n",
      "        \n",
      "        scale_units : {'width', 'height', 'dots', 'inches', 'x', 'y', 'xy'}, optional\n",
      "            If the *scale* kwarg is *None*, the arrow length unit. Default is *None*.\n",
      "        \n",
      "            e.g. *scale_units* is 'inches', *scale* is 2.0, and ``(u, v) = (1, 0)``,\n",
      "            then the vector will be 0.5 inches long.\n",
      "        \n",
      "            If *scale_units* is 'width' or 'height', then the vector will be half the\n",
      "            width/height of the axes.\n",
      "        \n",
      "            If *scale_units* is 'x' then the vector will be 0.5 x-axis\n",
      "            units. To plot vectors in the x-y plane, with u and v having\n",
      "            the same units as x and y, use\n",
      "            ``angles='xy', scale_units='xy', scale=1``.\n",
      "        \n",
      "        width : float, optional\n",
      "            Shaft width in arrow units; default depends on choice of units,\n",
      "            above, and number of vectors; a typical starting value is about\n",
      "            0.005 times the width of the plot.\n",
      "        \n",
      "        headwidth : float, default: 3\n",
      "            Head width as multiple of shaft width.\n",
      "        \n",
      "        headlength : float, default: 5\n",
      "            Head length as multiple of shaft width.\n",
      "        \n",
      "        headaxislength : float, default: 4.5\n",
      "            Head length at shaft intersection.\n",
      "        \n",
      "        minshaft : float, default: 1\n",
      "            Length below which arrow scales, in units of head length. Do not\n",
      "            set this to less than 1, or small arrows will look terrible!\n",
      "        \n",
      "        minlength : float, default: 1\n",
      "            Minimum length as a multiple of shaft width; if an arrow length\n",
      "            is less than this, plot a dot (hexagon) of this diameter instead.\n",
      "        \n",
      "        pivot : {'tail', 'mid', 'middle', 'tip'}, default: 'tail'\n",
      "            The part of the arrow that is anchored to the *X*, *Y* grid. The arrow\n",
      "            rotates about this point.\n",
      "        \n",
      "            'mid' is a synonym for 'middle'.\n",
      "        \n",
      "        color : color or color sequence, optional\n",
      "            Explicit color(s) for the arrows. If *C* has been set, *color* has no\n",
      "            effect.\n",
      "        \n",
      "            This is a synonym for the `~.PolyCollection` *facecolor* parameter.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.collections.PolyCollection` properties, optional\n",
      "            All other keyword arguments are passed on to `.PolyCollection`:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: array-like or scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa or antialiaseds: bool or list of bools\n",
      "            array: ndarray or None\n",
      "            capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            clim: (vmin: float, vmax: float)\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            cmap: `.Colormap` or str or None\n",
      "            color: color or list of rgba tuples\n",
      "            contains: unknown\n",
      "            edgecolor or ec or edgecolors: color or list of colors or 'face'\n",
      "            facecolor or facecolors or fc: color or list of colors\n",
      "            figure: `.Figure`\n",
      "            gid: str\n",
      "            hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "            in_layout: bool\n",
      "            joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            label: object\n",
      "            linestyle or dashes or linestyles or ls: str or tuple or list thereof\n",
      "            linewidth or linewidths or lw: float or list of floats\n",
      "            norm: `.Normalize` or None\n",
      "            offset_position: unknown\n",
      "            offsets: (N, 2) or (2,) array-like\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            urls: list of str or None\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .Axes.quiverkey : Add a key to a quiver plot.\n",
      "    \n",
      "    quiverkey(Q, X, Y, U, label, **kw)\n",
      "        Add a key to a quiver plot.\n",
      "        \n",
      "        The positioning of the key depends on *X*, *Y*, *coordinates*, and\n",
      "        *labelpos*.  If *labelpos* is 'N' or 'S', *X*, *Y* give the position of\n",
      "        the middle of the key arrow.  If *labelpos* is 'E', *X*, *Y* positions\n",
      "        the head, and if *labelpos* is 'W', *X*, *Y* positions the tail; in\n",
      "        either of these two cases, *X*, *Y* is somewhere in the middle of the\n",
      "        arrow+label key object.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        Q : `matplotlib.quiver.Quiver`\n",
      "            A `.Quiver` object as returned by a call to `~.Axes.quiver()`.\n",
      "        X, Y : float\n",
      "            The location of the key.\n",
      "        U : float\n",
      "            The length of the key.\n",
      "        label : str\n",
      "            The key label (e.g., length and units of the key).\n",
      "        angle : float, default: 0\n",
      "            The angle of the key arrow, in degrees anti-clockwise from the\n",
      "            x-axis.\n",
      "        coordinates : {'axes', 'figure', 'data', 'inches'}, default: 'axes'\n",
      "            Coordinate system and units for *X*, *Y*: 'axes' and 'figure' are\n",
      "            normalized coordinate systems with (0, 0) in the lower left and\n",
      "            (1, 1) in the upper right; 'data' are the axes data coordinates\n",
      "            (used for the locations of the vectors in the quiver plot itself);\n",
      "            'inches' is position in the figure in inches, with (0, 0) at the\n",
      "            lower left corner.\n",
      "        color : color\n",
      "            Overrides face and edge colors from *Q*.\n",
      "        labelpos : {'N', 'S', 'E', 'W'}\n",
      "            Position the label above, below, to the right, to the left of the\n",
      "            arrow, respectively.\n",
      "        labelsep : float, default: 0.1\n",
      "            Distance in inches between the arrow and the label.\n",
      "        labelcolor : color, default: :rc:`text.color`\n",
      "            Label color.\n",
      "        fontproperties : dict, optional\n",
      "            A dictionary with keyword arguments accepted by the\n",
      "            `~matplotlib.font_manager.FontProperties` initializer:\n",
      "            *family*, *style*, *variant*, *size*, *weight*.\n",
      "        **kwargs\n",
      "            Any additional keyword arguments are used to override vector\n",
      "            properties taken from *Q*.\n",
      "    \n",
      "    rc(group, **kwargs)\n",
      "        Set the current `.rcParams`.  *group* is the grouping for the rc, e.g.,\n",
      "        for ``lines.linewidth`` the group is ``lines``, for\n",
      "        ``axes.facecolor``, the group is ``axes``, and so on.  Group may\n",
      "        also be a list or tuple of group names, e.g., (*xtick*, *ytick*).\n",
      "        *kwargs* is a dictionary attribute name/value pairs, e.g.,::\n",
      "        \n",
      "          rc('lines', linewidth=2, color='r')\n",
      "        \n",
      "        sets the current `.rcParams` and is equivalent to::\n",
      "        \n",
      "          rcParams['lines.linewidth'] = 2\n",
      "          rcParams['lines.color'] = 'r'\n",
      "        \n",
      "        The following aliases are available to save typing for interactive users:\n",
      "        \n",
      "        =====   =================\n",
      "        Alias   Property\n",
      "        =====   =================\n",
      "        'lw'    'linewidth'\n",
      "        'ls'    'linestyle'\n",
      "        'c'     'color'\n",
      "        'fc'    'facecolor'\n",
      "        'ec'    'edgecolor'\n",
      "        'mew'   'markeredgewidth'\n",
      "        'aa'    'antialiased'\n",
      "        =====   =================\n",
      "        \n",
      "        Thus you could abbreviate the above call as::\n",
      "        \n",
      "              rc('lines', lw=2, c='r')\n",
      "        \n",
      "        Note you can use python's kwargs dictionary facility to store\n",
      "        dictionaries of default parameters.  e.g., you can customize the\n",
      "        font rc as follows::\n",
      "        \n",
      "          font = {'family' : 'monospace',\n",
      "                  'weight' : 'bold',\n",
      "                  'size'   : 'larger'}\n",
      "          rc('font', **font)  # pass in the font dict as kwargs\n",
      "        \n",
      "        This enables you to easily switch between several configurations.  Use\n",
      "        ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to\n",
      "        restore the default `.rcParams` after changes.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Similar functionality is available by using the normal dict interface, i.e.\n",
      "        ``rcParams.update({\"lines.linewidth\": 2, ...})`` (but ``rcParams.update``\n",
      "        does not support abbreviations or grouping).\n",
      "    \n",
      "    rc_context(rc=None, fname=None)\n",
      "        Return a context manager for temporarily changing rcParams.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        rc : dict\n",
      "            The rcParams to temporarily set.\n",
      "        fname : str or path-like\n",
      "            A file with Matplotlib rc settings. If both *fname* and *rc* are given,\n",
      "            settings from *rc* take precedence.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :ref:`customizing-with-matplotlibrc-files`\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Passing explicit values via a dict::\n",
      "        \n",
      "            with mpl.rc_context({'interactive': False}):\n",
      "                fig, ax = plt.subplots()\n",
      "                ax.plot(range(3), range(3))\n",
      "                fig.savefig('example.png')\n",
      "                plt.close(fig)\n",
      "        \n",
      "        Loading settings from a file::\n",
      "        \n",
      "             with mpl.rc_context(fname='print.rc'):\n",
      "                 plt.plot(x, y)  # uses 'print.rc'\n",
      "    \n",
      "    rcdefaults()\n",
      "        Restore the `.rcParams` from Matplotlib's internal default style.\n",
      "        \n",
      "        Style-blacklisted `.rcParams` (defined in\n",
      "        `matplotlib.style.core.STYLE_BLACKLIST`) are not updated.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.rc_file_defaults\n",
      "            Restore the `.rcParams` from the rc file originally loaded by\n",
      "            Matplotlib.\n",
      "        matplotlib.style.use\n",
      "            Use a specific style file.  Call ``style.use('default')`` to restore\n",
      "            the default style.\n",
      "    \n",
      "    rgrids(radii=None, labels=None, angle=None, fmt=None, **kwargs)\n",
      "        Get or set the radial gridlines on the current polar plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "         lines, labels = rgrids()\n",
      "         lines, labels = rgrids(radii, labels=None, angle=22.5, fmt=None, **kwargs)\n",
      "        \n",
      "        When called with no arguments, `.rgrids` simply returns the tuple\n",
      "        (*lines*, *labels*). When called with arguments, the labels will\n",
      "        appear at the specified radial distances and angle.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        radii : tuple with floats\n",
      "            The radii for the radial gridlines\n",
      "        \n",
      "        labels : tuple with strings or None\n",
      "            The labels to use at each radial gridline. The\n",
      "            `matplotlib.ticker.ScalarFormatter` will be used if None.\n",
      "        \n",
      "        angle : float\n",
      "            The angular position of the radius labels in degrees.\n",
      "        \n",
      "        fmt : str or None\n",
      "            Format string used in `matplotlib.ticker.FormatStrFormatter`.\n",
      "            For example '%f'.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : list of `.lines.Line2D`\n",
      "            The radial gridlines.\n",
      "        \n",
      "        labels : list of `.text.Text`\n",
      "            The tick labels.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            *kwargs* are optional `~.Text` properties for the labels.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .pyplot.thetagrids\n",
      "        .projections.polar.PolarAxes.set_rgrids\n",
      "        .Axis.get_gridlines\n",
      "        .Axis.get_ticklabels\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "          # set the locations of the radial gridlines\n",
      "          lines, labels = rgrids( (0.25, 0.5, 1.0) )\n",
      "        \n",
      "          # set the locations and labels of the radial gridlines\n",
      "          lines, labels = rgrids( (0.25, 0.5, 1.0), ('Tom', 'Dick', 'Harry' ))\n",
      "    \n",
      "    savefig(*args, **kwargs)\n",
      "        Save the current figure.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          savefig(fname, dpi=None, facecolor='w', edgecolor='w',\n",
      "                  orientation='portrait', papertype=None, format=None,\n",
      "                  transparent=False, bbox_inches=None, pad_inches=0.1,\n",
      "                  frameon=None, metadata=None)\n",
      "        \n",
      "        The available output formats depend on the backend being used.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fname : str or path-like or binary file-like\n",
      "            A path, or a Python file-like object, or\n",
      "            possibly some backend-dependent object such as\n",
      "            `matplotlib.backends.backend_pdf.PdfPages`.\n",
      "        \n",
      "            If *format* is set, it determines the output format, and the file\n",
      "            is saved as *fname*.  Note that *fname* is used verbatim, and there\n",
      "            is no attempt to make the extension, if any, of *fname* match\n",
      "            *format*, and no extension is appended.\n",
      "        \n",
      "            If *format* is not set, then the format is inferred from the\n",
      "            extension of *fname*, if there is one.  If *format* is not\n",
      "            set and *fname* has no extension, then the file is saved with\n",
      "            :rc:`savefig.format` and the appropriate extension is appended to\n",
      "            *fname*.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        dpi : float or 'figure', default: :rc:`savefig.dpi`\n",
      "            The resolution in dots per inch.  If 'figure', use the figure's\n",
      "            dpi value.\n",
      "        \n",
      "        quality : int, default: :rc:`savefig.jpeg_quality`\n",
      "            Applicable only if *format* is 'jpg' or 'jpeg', ignored otherwise.\n",
      "        \n",
      "            The image quality, on a scale from 1 (worst) to 95 (best).\n",
      "            Values above 95 should be avoided; 100 disables portions of\n",
      "            the JPEG compression algorithm, and results in large files\n",
      "            with hardly any gain in image quality.\n",
      "        \n",
      "            This parameter is deprecated.\n",
      "        \n",
      "        optimize : bool, default: False\n",
      "            Applicable only if *format* is 'jpg' or 'jpeg', ignored otherwise.\n",
      "        \n",
      "            Whether the encoder should make an extra pass over the image\n",
      "            in order to select optimal encoder settings.\n",
      "        \n",
      "            This parameter is deprecated.\n",
      "        \n",
      "        progressive : bool, default: False\n",
      "            Applicable only if *format* is 'jpg' or 'jpeg', ignored otherwise.\n",
      "        \n",
      "            Whether the image should be stored as a progressive JPEG file.\n",
      "        \n",
      "            This parameter is deprecated.\n",
      "        \n",
      "        facecolor : color or 'auto', default: :rc:`savefig.facecolor`\n",
      "            The facecolor of the figure.  If 'auto', use the current figure\n",
      "            facecolor.\n",
      "        \n",
      "        edgecolor : color or 'auto', default: :rc:`savefig.edgecolor`\n",
      "            The edgecolor of the figure.  If 'auto', use the current figure\n",
      "            edgecolor.\n",
      "        \n",
      "        orientation : {'landscape', 'portrait'}\n",
      "            Currently only supported by the postscript backend.\n",
      "        \n",
      "        papertype : str\n",
      "            One of 'letter', 'legal', 'executive', 'ledger', 'a0' through\n",
      "            'a10', 'b0' through 'b10'. Only supported for postscript\n",
      "            output.\n",
      "        \n",
      "        format : str\n",
      "            The file format, e.g. 'png', 'pdf', 'svg', ... The behavior when\n",
      "            this is unset is documented under *fname*.\n",
      "        \n",
      "        transparent : bool\n",
      "            If *True*, the Axes patches will all be transparent; the\n",
      "            figure patch will also be transparent unless facecolor\n",
      "            and/or edgecolor are specified via kwargs.\n",
      "            This is useful, for example, for displaying\n",
      "            a plot on top of a colored background on a web page.  The\n",
      "            transparency of these patches will be restored to their\n",
      "            original values upon exit of this function.\n",
      "        \n",
      "        bbox_inches : str or `.Bbox`, default: :rc:`savefig.bbox`\n",
      "            Bounding box in inches: only the given portion of the figure is\n",
      "            saved.  If 'tight', try to figure out the tight bbox of the figure.\n",
      "        \n",
      "        pad_inches : float, default: :rc:`savefig.pad_inches`\n",
      "            Amount of padding around the figure when bbox_inches is 'tight'.\n",
      "        \n",
      "        bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional\n",
      "            A list of extra artists that will be considered when the\n",
      "            tight bbox is calculated.\n",
      "        \n",
      "        backend : str, optional\n",
      "            Use a non-default backend to render the file, e.g. to render a\n",
      "            png file with the \"cairo\" backend rather than the default \"agg\",\n",
      "            or a pdf file with the \"pgf\" backend rather than the default\n",
      "            \"pdf\".  Note that the default backend is normally sufficient.  See\n",
      "            :ref:`the-builtin-backends` for a list of valid backends for each\n",
      "            file format.  Custom backends can be referenced as \"module://...\".\n",
      "        \n",
      "        metadata : dict, optional\n",
      "            Key/value pairs to store in the image metadata. The supported keys\n",
      "            and defaults depend on the image format and backend:\n",
      "        \n",
      "            - 'png' with Agg backend: See the parameter ``metadata`` of\n",
      "              `~.FigureCanvasAgg.print_png`.\n",
      "            - 'pdf' with pdf backend: See the parameter ``metadata`` of\n",
      "              `~.backend_pdf.PdfPages`.\n",
      "            - 'svg' with svg backend: See the parameter ``metadata`` of\n",
      "              `~.FigureCanvasSVG.print_svg`.\n",
      "            - 'eps' and 'ps' with PS backend: Only 'Creator' is supported.\n",
      "        \n",
      "        pil_kwargs : dict, optional\n",
      "            Additional keyword arguments that are passed to\n",
      "            `PIL.Image.Image.save` when saving the figure.\n",
      "    \n",
      "    sca(ax)\n",
      "        Set the current Axes to *ax* and the current Figure to the parent of *ax*.\n",
      "    \n",
      "    scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, *, edgecolors=None, plotnonfinite=False, data=None, **kwargs)\n",
      "        A scatter plot of *y* vs. *x* with varying marker size and/or color.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : float or array-like, shape (n, )\n",
      "            The data positions.\n",
      "        \n",
      "        s : float or array-like, shape (n, ), optional\n",
      "            The marker size in points**2.\n",
      "            Default is ``rcParams['lines.markersize'] ** 2``.\n",
      "        \n",
      "        c : array-like or list of colors or color, optional\n",
      "            The marker colors. Possible values:\n",
      "        \n",
      "            - A scalar or sequence of n numbers to be mapped to colors using\n",
      "              *cmap* and *norm*.\n",
      "            - A 2D array in which the rows are RGB or RGBA.\n",
      "            - A sequence of colors of length n.\n",
      "            - A single color format string.\n",
      "        \n",
      "            Note that *c* should not be a single numeric RGB or RGBA sequence\n",
      "            because that is indistinguishable from an array of values to be\n",
      "            colormapped. If you want to specify the same RGB or RGBA value for\n",
      "            all points, use a 2D array with a single row.  Otherwise, value-\n",
      "            matching will have precedence in case of a size matching with *x*\n",
      "            and *y*.\n",
      "        \n",
      "            If you wish to specify a single color for all points\n",
      "            prefer the *color* keyword argument.\n",
      "        \n",
      "            Defaults to `None`. In that case the marker color is determined\n",
      "            by the value of *color*, *facecolor* or *facecolors*. In case\n",
      "            those are not specified or `None`, the marker color is determined\n",
      "            by the next color of the ``Axes``' current \"shape and fill\" color\n",
      "            cycle. This cycle defaults to :rc:`axes.prop_cycle`.\n",
      "        \n",
      "        marker : `~.markers.MarkerStyle`, default: :rc:`scatter.marker`\n",
      "            The marker style. *marker* can be either an instance of the class\n",
      "            or the text shorthand for a particular marker.\n",
      "            See :mod:`matplotlib.markers` for more information about marker\n",
      "            styles.\n",
      "        \n",
      "        cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`\n",
      "            A `.Colormap` instance or registered colormap name. *cmap* is only\n",
      "            used if *c* is an array of floats.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, default: None\n",
      "            If *c* is an array of floats, *norm* is used to scale the color\n",
      "            data, *c*, in the range 0 to 1, in order to map into the colormap\n",
      "            *cmap*.\n",
      "            If *None*, use the default `.colors.Normalize`.\n",
      "        \n",
      "        vmin, vmax : float, default: None\n",
      "            *vmin* and *vmax* are used in conjunction with the default norm to\n",
      "            map the color array *c* to the colormap *cmap*. If None, the\n",
      "            respective min and max of the color array is used.\n",
      "            It is deprecated to use *vmin*/*vmax* when *norm* is given.\n",
      "        \n",
      "        alpha : float, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        linewidths : float or array-like, default: :rc:`lines.linewidth`\n",
      "            The linewidth of the marker edges. Note: The default *edgecolors*\n",
      "            is 'face'. You may want to change this as well.\n",
      "        \n",
      "        edgecolors : {'face', 'none', *None*} or color or sequence of color, default: :rc:`scatter.edgecolors`\n",
      "            The edge color of the marker. Possible values:\n",
      "        \n",
      "            - 'face': The edge color will always be the same as the face color.\n",
      "            - 'none': No patch boundary will be drawn.\n",
      "            - A color or sequence of colors.\n",
      "        \n",
      "            For non-filled markers, *edgecolors* is ignored. Instead, the color\n",
      "            is determined like with 'face', i.e. from *c*, *colors*, or\n",
      "            *facecolors*.\n",
      "        \n",
      "        plotnonfinite : bool, default: False\n",
      "            Whether to plot points with nonfinite *c* (i.e. ``inf``, ``-inf``\n",
      "            or ``nan``). If ``True`` the points are drawn with the *bad*\n",
      "            colormap color (see `.Colormap.set_bad`).\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.collections.PathCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.collections.Collection` properties\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        plot : To plot scatter plots when markers are identical in size and\n",
      "            color.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        * The `.plot` function will be faster for scatterplots where markers\n",
      "          don't vary in size or color.\n",
      "        \n",
      "        * Any or all of *x*, *y*, *s*, and *c* may be masked arrays, in which\n",
      "          case all masks will be combined and only unmasked points will be\n",
      "          plotted.\n",
      "        \n",
      "        * Fundamentally, scatter works with 1D arrays; *x*, *y*, *s*, and *c*\n",
      "          may be input as N-D arrays, but within scatter they will be\n",
      "          flattened. The exception is *c*, which will be flattened only if its\n",
      "          size matches the size of *x* and *y*.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*, *s*, *linewidths*, *edgecolors*, *c*, *facecolor*, *facecolors*, *color*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    sci(im)\n",
      "        Set the current image.\n",
      "        \n",
      "        This image will be the target of colormap functions like\n",
      "        `~.pyplot.viridis`, and other functions such as `~.pyplot.clim`.  The\n",
      "        current image is an attribute of the current axes.\n",
      "    \n",
      "    semilogx(*args, **kwargs)\n",
      "        Make a plot with log scaling on the x axis.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            semilogx([x], y, [fmt], data=None, **kwargs)\n",
      "            semilogx([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      "        \n",
      "        This is just a thin wrapper around `.plot` which additionally changes\n",
      "        the x-axis to log scaling. All of the concepts and parameters of plot\n",
      "        can be used here as well.\n",
      "        \n",
      "        The additional parameters *base*, *subs*, and *nonpositive* control the\n",
      "        x-axis properties. They are just forwarded to `.Axes.set_xscale`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        base : float, default: 10\n",
      "            Base of the x logarithm.\n",
      "        \n",
      "        subs : array-like, optional\n",
      "            The location of the minor xticks. If *None*, reasonable locations\n",
      "            are automatically chosen depending on the number of decades in the\n",
      "            plot. See `.Axes.set_xscale` for details.\n",
      "        \n",
      "        nonpositive : {'mask', 'clip'}, default: 'mask'\n",
      "            Non-positive values in x can be masked as invalid, or clipped to a\n",
      "            very small positive number.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `~.Line2D`\n",
      "            Objects representing the plotted data.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All parameters supported by `.plot`.\n",
      "    \n",
      "    semilogy(*args, **kwargs)\n",
      "        Make a plot with log scaling on the y axis.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            semilogy([x], y, [fmt], data=None, **kwargs)\n",
      "            semilogy([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n",
      "        \n",
      "        This is just a thin wrapper around `.plot` which additionally changes\n",
      "        the y-axis to log scaling. All of the concepts and parameters of plot\n",
      "        can be used here as well.\n",
      "        \n",
      "        The additional parameters *base*, *subs*, and *nonpositive* control the\n",
      "        y-axis properties. They are just forwarded to `.Axes.set_yscale`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        base : float, default: 10\n",
      "            Base of the y logarithm.\n",
      "        \n",
      "        subs : array-like, optional\n",
      "            The location of the minor yticks. If *None*, reasonable locations\n",
      "            are automatically chosen depending on the number of decades in the\n",
      "            plot. See `.Axes.set_yscale` for details.\n",
      "        \n",
      "        nonpositive : {'mask', 'clip'}, default: 'mask'\n",
      "            Non-positive values in y can be masked as invalid, or clipped to a\n",
      "            very small positive number.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `~.Line2D`\n",
      "            Objects representing the plotted data.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All parameters supported by `.plot`.\n",
      "    \n",
      "    set_cmap(cmap)\n",
      "        Set the default colormap, and applies it to the current image if any.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        cmap : `~matplotlib.colors.Colormap` or str\n",
      "            A colormap instance or the name of a registered colormap.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        colormaps\n",
      "        matplotlib.cm.register_cmap\n",
      "        matplotlib.cm.get_cmap\n",
      "    \n",
      "    setp(obj, *args, **kwargs)\n",
      "        Set one or more properties on an `.Artist`, or list allowed values.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        obj : `.Artist` or list of `.Artist`\n",
      "            The artist(s) whose properties are being set or queried.  When setting\n",
      "            properties, all artists are affected; when querying the allowed values,\n",
      "            only the first instance in the sequence is queried.\n",
      "        \n",
      "            For example, two lines can be made thicker and red with a single call:\n",
      "        \n",
      "            >>> x = arange(0, 1, 0.01)\n",
      "            >>> lines = plot(x, sin(2*pi*x), x, sin(4*pi*x))\n",
      "            >>> setp(lines, linewidth=2, color='r')\n",
      "        \n",
      "        file : file-like, default: `sys.stdout`\n",
      "            Where `setp` writes its output when asked to list allowed values.\n",
      "        \n",
      "            >>> with open('output.log') as file:\n",
      "            ...     setp(line, file=file)\n",
      "        \n",
      "            The default, ``None``, means `sys.stdout`.\n",
      "        \n",
      "        *args, **kwargs\n",
      "            The properties to set.  The following combinations are supported:\n",
      "        \n",
      "            - Set the linestyle of a line to be dashed:\n",
      "        \n",
      "              >>> line, = plot([1, 2, 3])\n",
      "              >>> setp(line, linestyle='--')\n",
      "        \n",
      "            - Set multiple properties at once:\n",
      "        \n",
      "              >>> setp(line, linewidth=2, color='r')\n",
      "        \n",
      "            - List allowed values for a line's linestyle:\n",
      "        \n",
      "              >>> setp(line, 'linestyle')\n",
      "              linestyle: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "        \n",
      "            - List all properties that can be set, and their allowed values:\n",
      "        \n",
      "              >>> setp(line)\n",
      "              agg_filter: a filter function, ...\n",
      "              [long output listing omitted]\n",
      "        \n",
      "            `setp` also supports MATLAB style string/value pairs.  For example, the\n",
      "            following are equivalent:\n",
      "        \n",
      "            >>> setp(lines, 'linewidth', 2, 'color', 'r')  # MATLAB style\n",
      "            >>> setp(lines, linewidth=2, color='r')        # Python style\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        getp\n",
      "    \n",
      "    show(close=None, block=None)\n",
      "        Display all open figures.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        block : bool, optional\n",
      "            Whether to wait for all figures to be closed before returning.\n",
      "        \n",
      "            If `True` block and run the GUI main loop until all figure windows\n",
      "            are closed.\n",
      "        \n",
      "            If `False` ensure that all figure windows are displayed and return\n",
      "            immediately.  In this case, you are responsible for ensuring\n",
      "            that the event loop is running to have responsive figures.\n",
      "        \n",
      "            Defaults to True in non-interactive mode and to False in interactive\n",
      "            mode (see `.pyplot.isinteractive`).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ion : Enable interactive mode, which shows / updates the figure after\n",
      "              every plotting command, so that calling ``show()`` is not necessary.\n",
      "        ioff : Disable interactive mode.\n",
      "        savefig : Save the figure to an image file instead of showing it on screen.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        **Saving figures to file and showing a window at the same time**\n",
      "        \n",
      "        If you want an image file as well as a user interface window, use\n",
      "        `.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
      "        ``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
      "        `.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
      "        limitation of command order does not apply if the show is non-blocking or\n",
      "        if you keep a reference to the figure and use `.Figure.savefig`.\n",
      "        \n",
      "        **Auto-show in jupyter notebooks**\n",
      "        \n",
      "        The jupyter backends (activated via ``%matplotlib inline``,\n",
      "        ``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
      "        the end of every cell by default. Thus, you usually don't have to call it\n",
      "        explicitly there.\n",
      "    \n",
      "    specgram(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, *, data=None, **kwargs)\n",
      "        Plot a spectrogram.\n",
      "        \n",
      "        Compute and plot a spectrogram of data in *x*.  Data are split into\n",
      "        *NFFT* length segments and the spectrum of each section is\n",
      "        computed.  The windowing function *window* is applied to each\n",
      "        segment, and the amount of overlap of each segment is\n",
      "        specified with *noverlap*. The spectrogram is plotted as a colormap\n",
      "        (using imshow).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data.\n",
      "        \n",
      "        Fs : float, default: 2\n",
      "            The sampling frequency (samples per time unit).  It is used to calculate\n",
      "            the Fourier frequencies, *freqs*, in cycles per time unit.\n",
      "        \n",
      "        window : callable or ndarray, default: `.window_hanning`\n",
      "            A function or a vector of length *NFFT*.  To create window vectors see\n",
      "            `.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,\n",
      "            `numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc.  If a\n",
      "            function is passed as the argument, it must take a data segment as an\n",
      "            argument and return the windowed version of the segment.\n",
      "        \n",
      "        sides : {'default', 'onesided', 'twosided'}, optional\n",
      "            Which sides of the spectrum to return. 'default' is one-sided for real\n",
      "            data and two-sided for complex data. 'onesided' forces the return of a\n",
      "            one-sided spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : int, optional\n",
      "            The number of points to which the data segment is padded when performing\n",
      "            the FFT.  This can be different from *NFFT*, which specifies the number\n",
      "            of data points used.  While not increasing the actual resolution of the\n",
      "            spectrum (the minimum distance between resolvable peaks), this can give\n",
      "            more points in the plot, allowing for more detail. This corresponds to\n",
      "            the *n* parameter in the call to fft(). The default is None, which sets\n",
      "            *pad_to* equal to *NFFT*\n",
      "        \n",
      "        NFFT : int, default: 256\n",
      "            The number of data points used in each block for the FFT.  A power 2 is\n",
      "            most efficient.  This should *NOT* be used to get zero padding, or the\n",
      "            scaling of the result will be incorrect; use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'none', 'mean', 'linear'} or callable, default: 'none'\n",
      "            The function applied to each segment before fft-ing, designed to remove\n",
      "            the mean or linear trend.  Unlike in MATLAB, where the *detrend* parameter\n",
      "            is a vector, in Matplotlib is it a function.  The :mod:`~matplotlib.mlab`\n",
      "            module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,\n",
      "            but you can use a custom function as well.  You can also use a string to\n",
      "            choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls\n",
      "            `.detrend_mean`. 'linear' calls `.detrend_linear`.\n",
      "        \n",
      "        scale_by_freq : bool, default: True\n",
      "            Whether the resulting density values should be scaled by the scaling\n",
      "            frequency, which gives density in units of Hz^-1.  This allows for\n",
      "            integration over the returned frequency values.  The default is True for\n",
      "            MATLAB compatibility.\n",
      "        \n",
      "        mode : {'default', 'psd', 'magnitude', 'angle', 'phase'}\n",
      "            What sort of spectrum to use.  Default is 'psd', which takes the\n",
      "            power spectral density.  'magnitude' returns the magnitude\n",
      "            spectrum.  'angle' returns the phase spectrum without unwrapping.\n",
      "            'phase' returns the phase spectrum with unwrapping.\n",
      "        \n",
      "        noverlap : int, default: 128\n",
      "            The number of points of overlap between blocks.\n",
      "        \n",
      "        scale : {'default', 'linear', 'dB'}\n",
      "            The scaling of the values in the *spec*.  'linear' is no scaling.\n",
      "            'dB' returns the values in dB scale.  When *mode* is 'psd',\n",
      "            this is dB power (10 * log10).  Otherwise this is dB amplitude\n",
      "            (20 * log10). 'default' is 'dB' if *mode* is 'psd' or\n",
      "            'magnitude' and 'linear' otherwise.  This must be 'linear'\n",
      "            if *mode* is 'angle' or 'phase'.\n",
      "        \n",
      "        Fc : int, default: 0\n",
      "            The center frequency of *x*, which offsets the x extents of the\n",
      "            plot to reflect the frequency range used when a signal is acquired\n",
      "            and then filtered and downsampled to baseband.\n",
      "        \n",
      "        cmap : `.Colormap`, default: :rc:`image.cmap`\n",
      "        \n",
      "        xextent : *None* or (xmin, xmax)\n",
      "            The image extent along the x-axis. The default sets *xmin* to the\n",
      "            left border of the first bin (*spectrum* column) and *xmax* to the\n",
      "            right border of the last bin. Note that for *noverlap>0* the width\n",
      "            of the bins is smaller than those of the segments.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional keyword arguments are passed on to `~.axes.Axes.imshow`\n",
      "            which makes the specgram image. The origin keyword argument\n",
      "            is not supported.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 2D array\n",
      "            Columns are the periodograms of successive segments.\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the rows in *spectrum*.\n",
      "        \n",
      "        t : 1-D array\n",
      "            The times corresponding to midpoints of segments (i.e., the columns\n",
      "            in *spectrum*).\n",
      "        \n",
      "        im : `.AxesImage`\n",
      "            The image created by imshow containing the spectrogram.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        psd\n",
      "            Differs in the default overlap; in returning the mean of the\n",
      "            segment periodograms; in not returning times; and in generating a\n",
      "            line plot instead of colormap.\n",
      "        magnitude_spectrum\n",
      "            A single spectrum, similar to having a single segment when *mode*\n",
      "            is 'magnitude'. Plots a line instead of a colormap.\n",
      "        angle_spectrum\n",
      "            A single spectrum, similar to having a single segment when *mode*\n",
      "            is 'angle'. Plots a line instead of a colormap.\n",
      "        phase_spectrum\n",
      "            A single spectrum, similar to having a single segment when *mode*\n",
      "            is 'phase'. Plots a line instead of a colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The parameters *detrend* and *scale_by_freq* do only apply when *mode*\n",
      "        is set to 'psd'.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    spring()\n",
      "        Set the colormap to 'spring'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    spy(Z, precision=0, marker=None, markersize=None, aspect='equal', origin='upper', **kwargs)\n",
      "        Plot the sparsity pattern of a 2D array.\n",
      "        \n",
      "        This visualizes the non-zero values of the array.\n",
      "        \n",
      "        Two plotting styles are available: image and marker. Both\n",
      "        are available for full arrays, but only the marker style\n",
      "        works for `scipy.sparse.spmatrix` instances.\n",
      "        \n",
      "        **Image style**\n",
      "        \n",
      "        If *marker* and *markersize* are *None*, `~.Axes.imshow` is used. Any\n",
      "        extra remaining keyword arguments are passed to this method.\n",
      "        \n",
      "        **Marker style**\n",
      "        \n",
      "        If *Z* is a `scipy.sparse.spmatrix` or *marker* or *markersize* are\n",
      "        *None*, a `.Line2D` object will be returned with the value of marker\n",
      "        determining the marker type, and any remaining keyword arguments\n",
      "        passed to `~.Axes.plot`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        Z : (M, N) array-like\n",
      "            The array to be plotted.\n",
      "        \n",
      "        precision : float or 'present', default: 0\n",
      "            If *precision* is 0, any non-zero value will be plotted. Otherwise,\n",
      "            values of :math:`|Z| > precision` will be plotted.\n",
      "        \n",
      "            For `scipy.sparse.spmatrix` instances, you can also\n",
      "            pass 'present'. In this case any value present in the array\n",
      "            will be plotted, even if it is identically zero.\n",
      "        \n",
      "        aspect : {'equal', 'auto', None} or float, default: 'equal'\n",
      "            The aspect ratio of the Axes.  This parameter is particularly\n",
      "            relevant for images since it determines whether data pixels are\n",
      "            square.\n",
      "        \n",
      "            This parameter is a shortcut for explicitly calling\n",
      "            `.Axes.set_aspect`. See there for further details.\n",
      "        \n",
      "            - 'equal': Ensures an aspect ratio of 1. Pixels will be square.\n",
      "            - 'auto': The Axes is kept fixed and the aspect is adjusted so\n",
      "              that the data fit in the Axes. In general, this will result in\n",
      "              non-square pixels.\n",
      "            - *None*: Use :rc:`image.aspect`.\n",
      "        \n",
      "        origin : {'upper', 'lower'}, default: :rc:`image.origin`\n",
      "            Place the [0, 0] index of the array in the upper left or lower left\n",
      "            corner of the Axes. The convention 'upper' is typically used for\n",
      "            matrices and images.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.image.AxesImage` or `.Line2D`\n",
      "            The return type depends on the plotting style (see above).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            The supported additional parameters depend on the plotting style.\n",
      "        \n",
      "            For the image style, you can pass the following additional\n",
      "            parameters of `~.Axes.imshow`:\n",
      "        \n",
      "            - *cmap*\n",
      "            - *alpha*\n",
      "            - *url*\n",
      "            - any `.Artist` properties (passed on to the `.AxesImage`)\n",
      "        \n",
      "            For the marker style, you can pass any `.Line2D` property except\n",
      "            for *linestyle*:\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            antialiased or aa: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            dash_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            dash_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            dashes: sequence of floats (on/off ink in points) or (None, None)\n",
      "            data: (2, N) array or two 1D arrays\n",
      "            drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n",
      "            figure: `.Figure`\n",
      "            fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "            linewidth or lw: float\n",
      "            marker: marker style string, `~.path.Path` or `~.markers.MarkerStyle`\n",
      "            markeredgecolor or mec: color\n",
      "            markeredgewidth or mew: float\n",
      "            markerfacecolor or mfc: color\n",
      "            markerfacecoloralt or mfcalt: color\n",
      "            markersize or ms: float\n",
      "            markevery: None or int or (int, int) or slice or list[int] or float or (float, float) or list[bool]\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: float or callable[[Artist, Event], tuple[bool, dict]]\n",
      "            pickradius: float\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            solid_capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "            solid_joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "            transform: `matplotlib.transforms.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xdata: 1D array\n",
      "            ydata: 1D array\n",
      "            zorder: float\n",
      "    \n",
      "    stackplot(x, *args, labels=(), colors=None, baseline='zero', data=None, **kwargs)\n",
      "        Draw a stacked area plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : (N,) array-like\n",
      "        \n",
      "        y : (M, N) array-like\n",
      "            The data is assumed to be unstacked. Each of the following\n",
      "            calls is legal::\n",
      "        \n",
      "                stackplot(x, y)           # where y has shape (M, N)\n",
      "                stackplot(x, y1, y2, y3)  # where y1, y2, y3, y4 have length N\n",
      "        \n",
      "        baseline : {'zero', 'sym', 'wiggle', 'weighted_wiggle'}\n",
      "            Method used to calculate the baseline:\n",
      "        \n",
      "            - ``'zero'``: Constant zero baseline, i.e. a simple stacked plot.\n",
      "            - ``'sym'``:  Symmetric around zero and is sometimes called\n",
      "              'ThemeRiver'.\n",
      "            - ``'wiggle'``: Minimizes the sum of the squared slopes.\n",
      "            - ``'weighted_wiggle'``: Does the same but weights to account for\n",
      "              size of each layer. It is also called 'Streamgraph'-layout. More\n",
      "              details can be found at http://leebyron.com/streamgraph/.\n",
      "        \n",
      "        labels : list of str, optional\n",
      "            A sequence of labels to assign to each data series. If unspecified,\n",
      "            then no labels will be applied to artists.\n",
      "        \n",
      "        colors : list of color, optional\n",
      "            A sequence of colors to be cycled through and used to color the stacked\n",
      "            areas. The sequence need not be exactly the same length as the number\n",
      "            of provided *y*, in which case the colors will repeat from the\n",
      "            beginning.\n",
      "        \n",
      "            If not specified, the colors from the Axes property cycle will be used.\n",
      "        \n",
      "        **kwargs\n",
      "            All other keyword arguments are passed to `.Axes.fill_between`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `.PolyCollection`\n",
      "            A list of `.PolyCollection` instances, one for each element in the\n",
      "            stacked area plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    stairs(values, edges=None, *, orientation='vertical', baseline=0, fill=False, data=None, **kwargs)\n",
      "        A stepwise constant function as a line with bounding edges\n",
      "        or a filled plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        values : array-like\n",
      "            The step heights.\n",
      "        \n",
      "        edges : array-like\n",
      "            The edge positions, with ``len(edges) == len(vals) + 1``,\n",
      "            between which the curve takes on vals values.\n",
      "        \n",
      "        orientation : {'vertical', 'horizontal'}, default: 'vertical'\n",
      "            The direction of the steps. Vertical means that *values* are along\n",
      "            the y-axis, and edges are along the x-axis.\n",
      "        \n",
      "        baseline : float, array-like or None, default: 0\n",
      "            The bottom value of the bounding edges or when\n",
      "            ``fill=True``, position of lower edge. If *fill* is\n",
      "            True or an array is passed to *baseline*, a closed\n",
      "            path is drawn.\n",
      "        \n",
      "        fill : bool, default: False\n",
      "            Whether the area under the step curve should be filled.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        StepPatch : `matplotlib.patches.StepPatch`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            `~matplotlib.patches.StepPatch` properties\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    stem(*args, linefmt=None, markerfmt=None, basefmt=None, bottom=0, label=None, use_line_collection=True, orientation='vertical', data=None)\n",
      "        Create a stem plot.\n",
      "        \n",
      "        A stem plot draws lines perpendicular to a baseline at each location\n",
      "        *locs* from the baseline to *heads*, and places a marker there. For\n",
      "        vertical stem plots (the default), the *locs* are *x* positions, and\n",
      "        the *heads* are *y* values. For horizontal stem plots, the *locs* are\n",
      "        *y* positions, and the *heads* are *x* values.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          stem([locs,] heads, linefmt=None, markerfmt=None, basefmt=None)\n",
      "        \n",
      "        The *locs*-positions are optional. The formats may be provided either\n",
      "        as positional or as keyword-arguments.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        locs : array-like, default: (0, 1, ..., len(heads) - 1)\n",
      "            For vertical stem plots, the x-positions of the stems.\n",
      "            For horizontal stem plots, the y-positions of the stems.\n",
      "        \n",
      "        heads : array-like\n",
      "            For vertical stem plots, the y-values of the stem heads.\n",
      "            For horizontal stem plots, the x-values of the stem heads.\n",
      "        \n",
      "        linefmt : str, optional\n",
      "            A string defining the color and/or linestyle of the vertical lines:\n",
      "        \n",
      "            =========  =============\n",
      "            Character  Line Style\n",
      "            =========  =============\n",
      "            ``'-'``    solid line\n",
      "            ``'--'``   dashed line\n",
      "            ``'-.'``   dash-dot line\n",
      "            ``':'``    dotted line\n",
      "            =========  =============\n",
      "        \n",
      "            Default: 'C0-', i.e. solid line with the first color of the color\n",
      "            cycle.\n",
      "        \n",
      "            Note: Markers specified through this parameter (e.g. 'x') will be\n",
      "            silently ignored (unless using ``use_line_collection=False``).\n",
      "            Instead, markers should be specified using *markerfmt*.\n",
      "        \n",
      "        markerfmt : str, optional\n",
      "            A string defining the color and/or shape of the markers at the stem\n",
      "            heads.  Default: 'C0o', i.e. filled circles with the first color of\n",
      "            the color cycle.\n",
      "        \n",
      "        basefmt : str, default: 'C3-' ('C2-' in classic mode)\n",
      "            A format string defining the properties of the baseline.\n",
      "        \n",
      "        orientation : str, default: 'vertical'\n",
      "            If 'vertical', will produce a plot with stems oriented vertically,\n",
      "            otherwise the stems will be oriented horizontally.\n",
      "        \n",
      "        bottom : float, default: 0\n",
      "            The y/x-position of the baseline (depending on orientation).\n",
      "        \n",
      "        label : str, default: None\n",
      "            The label to use for the stems in legends.\n",
      "        \n",
      "        use_line_collection : bool, default: True\n",
      "            If ``True``, store and plot the stem lines as a\n",
      "            `~.collections.LineCollection` instead of individual lines, which\n",
      "            significantly increases performance.  If ``False``, defaults to the\n",
      "            old behavior of using a list of `.Line2D` objects.  This parameter\n",
      "            may be deprecated in the future.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.StemContainer`\n",
      "            The container may be treated like a tuple\n",
      "            (*markerline*, *stemlines*, *baseline*)\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. seealso::\n",
      "            The MATLAB function\n",
      "            `stem <https://www.mathworks.com/help/matlab/ref/stem.html>`_\n",
      "            which inspired this method.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            every other argument can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception).\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    step(x, y, *args, where='pre', data=None, **kwargs)\n",
      "        Make a step plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            step(x, y, [fmt], *, data=None, where='pre', **kwargs)\n",
      "            step(x, y, [fmt], x2, y2, [fmt2], ..., *, where='pre', **kwargs)\n",
      "        \n",
      "        This is just a thin wrapper around `.plot` which changes some\n",
      "        formatting options. Most of the concepts and parameters of plot can be\n",
      "        used here as well.\n",
      "        \n",
      "        .. note::\n",
      "        \n",
      "            This method uses a standard plot with a step drawstyle: The *x*\n",
      "            values are the reference positions and steps extend left/right/both\n",
      "            directions depending on *where*.\n",
      "        \n",
      "            For the common case where you know the values and edges of the\n",
      "            steps, use `~.Axes.stairs` instead.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array-like\n",
      "            1D sequence of x positions. It is assumed, but not checked, that\n",
      "            it is uniformly increasing.\n",
      "        \n",
      "        y : array-like\n",
      "            1D sequence of y levels.\n",
      "        \n",
      "        fmt : str, optional\n",
      "            A format string, e.g. 'g' for a green line. See `.plot` for a more\n",
      "            detailed description.\n",
      "        \n",
      "            Note: While full format strings are accepted, it is recommended to\n",
      "            only specify the color. Line styles are currently ignored (use\n",
      "            the keyword argument *linestyle* instead). Markers are accepted\n",
      "            and plotted on the given positions, however, this is a rarely\n",
      "            needed feature for step plots.\n",
      "        \n",
      "        data : indexable object, optional\n",
      "            An object with labelled data. If given, provide the label names to\n",
      "            plot in *x* and *y*.\n",
      "        \n",
      "        where : {'pre', 'post', 'mid'}, default: 'pre'\n",
      "            Define where the steps should be placed:\n",
      "        \n",
      "            - 'pre': The y value is continued constantly to the left from\n",
      "              every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the\n",
      "              value ``y[i]``.\n",
      "            - 'post': The y value is continued constantly to the right from\n",
      "              every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the\n",
      "              value ``y[i]``.\n",
      "            - 'mid': Steps occur half-way between the *x* positions.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list of `.Line2D`\n",
      "            Objects representing the plotted data.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Additional parameters are the same as those for `.plot`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [notes section required to get data note injection right]\n",
      "    \n",
      "    streamplot(x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', *, data=None)\n",
      "        Draw streamlines of a vector flow.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : 1D/2D arrays\n",
      "            Evenly spaced strictly increasing arrays to make a grid.\n",
      "        u, v : 2D arrays\n",
      "            *x* and *y*-velocities. The number of rows and columns must match\n",
      "            the length of *y* and *x*, respectively.\n",
      "        density : float or (float, float)\n",
      "            Controls the closeness of streamlines. When ``density = 1``, the domain\n",
      "            is divided into a 30x30 grid. *density* linearly scales this grid.\n",
      "            Each cell in the grid can have, at most, one traversing streamline.\n",
      "            For different densities in each direction, use a tuple\n",
      "            (density_x, density_y).\n",
      "        linewidth : float or 2D array\n",
      "            The width of the stream lines. With a 2D array the line width can be\n",
      "            varied across the grid. The array must have the same shape as *u*\n",
      "            and *v*.\n",
      "        color : color or 2D array\n",
      "            The streamline color. If given an array, its values are converted to\n",
      "            colors using *cmap* and *norm*.  The array must have the same shape\n",
      "            as *u* and *v*.\n",
      "        cmap : `~matplotlib.colors.Colormap`\n",
      "            Colormap used to plot streamlines and arrows. This is only used if\n",
      "            *color* is an array.\n",
      "        norm : `~matplotlib.colors.Normalize`\n",
      "            Normalize object used to scale luminance data to 0, 1. If ``None``,\n",
      "            stretch (min, max) to (0, 1). This is only used if *color* is an array.\n",
      "        arrowsize : float\n",
      "            Scaling factor for the arrow size.\n",
      "        arrowstyle : str\n",
      "            Arrow style specification.\n",
      "            See `~matplotlib.patches.FancyArrowPatch`.\n",
      "        minlength : float\n",
      "            Minimum length of streamline in axes coordinates.\n",
      "        start_points : Nx2 array\n",
      "            Coordinates of starting points for the streamlines in data coordinates\n",
      "            (the same coordinates as the *x* and *y* arrays).\n",
      "        zorder : int\n",
      "            The zorder of the stream lines and arrows.\n",
      "            Artists with lower zorder values are drawn first.\n",
      "        maxlength : float\n",
      "            Maximum length of streamline in axes coordinates.\n",
      "        integration_direction : {'forward', 'backward', 'both'}, default: 'both'\n",
      "            Integrate the streamline in forward, backward or both directions.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        StreamplotSet\n",
      "            Container object with attributes\n",
      "        \n",
      "            - ``lines``: `.LineCollection` of streamlines\n",
      "        \n",
      "            - ``arrows``: `.PatchCollection` containing `.FancyArrowPatch`\n",
      "              objects representing the arrows half-way along stream lines.\n",
      "        \n",
      "            This container will probably change in the future to allow changes\n",
      "            to the colormap, alpha, etc. for both lines and arrows, but these\n",
      "            changes should be backward compatible.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*, *u*, *v*, *start_points*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    subplot(*args, **kwargs)\n",
      "        Add an Axes to the current figure or retrieve an existing Axes.\n",
      "        \n",
      "        This is a wrapper of `.Figure.add_subplot` which provides additional\n",
      "        behavior when working with the implicit API (see the notes section).\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "           subplot(nrows, ncols, index, **kwargs)\n",
      "           subplot(pos, **kwargs)\n",
      "           subplot(**kwargs)\n",
      "           subplot(ax)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        *args : int, (int, int, *index*), or `.SubplotSpec`, default: (1, 1, 1)\n",
      "            The position of the subplot described by one of\n",
      "        \n",
      "            - Three integers (*nrows*, *ncols*, *index*). The subplot will take the\n",
      "              *index* position on a grid with *nrows* rows and *ncols* columns.\n",
      "              *index* starts at 1 in the upper left corner and increases to the\n",
      "              right. *index* can also be a two-tuple specifying the (*first*,\n",
      "              *last*) indices (1-based, and including *last*) of the subplot, e.g.,\n",
      "              ``fig.add_subplot(3, 1, (1, 2))`` makes a subplot that spans the\n",
      "              upper 2/3 of the figure.\n",
      "            - A 3-digit integer. The digits are interpreted as if given separately\n",
      "              as three single-digit integers, i.e. ``fig.add_subplot(235)`` is the\n",
      "              same as ``fig.add_subplot(2, 3, 5)``. Note that this can only be used\n",
      "              if there are no more than 9 subplots.\n",
      "            - A `.SubplotSpec`.\n",
      "        \n",
      "        projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', 'rectilinear', str}, optional\n",
      "            The projection type of the subplot (`~.axes.Axes`). *str* is the name\n",
      "            of a custom projection, see `~matplotlib.projections`. The default\n",
      "            None results in a 'rectilinear' projection.\n",
      "        \n",
      "        polar : bool, default: False\n",
      "            If True, equivalent to projection='polar'.\n",
      "        \n",
      "        sharex, sharey : `~.axes.Axes`, optional\n",
      "            Share the x or y `~matplotlib.axis` with sharex and/or sharey. The\n",
      "            axis will have the same limits, ticks, and scale as the axis of the\n",
      "            shared axes.\n",
      "        \n",
      "        label : str\n",
      "            A label for the returned axes.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.axes.SubplotBase`, or another subclass of `~.axes.Axes`\n",
      "        \n",
      "            The axes of the subplot. The returned axes base class depends on\n",
      "            the projection used. It is `~.axes.Axes` if rectilinear projection\n",
      "            is used and `.projections.polar.PolarAxes` if polar projection\n",
      "            is used. The returned axes is then a subplot subclass of the\n",
      "            base class.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            This method also takes the keyword arguments for the returned axes\n",
      "            base class; except for the *figure* argument. The keyword arguments\n",
      "            for the rectilinear base class `~.axes.Axes` can be found in\n",
      "            the following table but there might also be other keyword\n",
      "            arguments if another projection is used.\n",
      "        \n",
      "            Properties:\n",
      "            adjustable: {'box', 'datalim'}\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}\n",
      "            animated: bool\n",
      "            aspect: {'auto', 'equal'} or float\n",
      "            autoscale_on: bool\n",
      "            autoscalex_on: bool\n",
      "            autoscaley_on: bool\n",
      "            axes_locator: Callable[[Axes, Renderer], Bbox]\n",
      "            axisbelow: bool or 'line'\n",
      "            box_aspect: float or None\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            contains: unknown\n",
      "            facecolor or fc: color\n",
      "            figure: `.Figure`\n",
      "            frame_on: bool\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            navigate: bool\n",
      "            navigate_mode: unknown\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n",
      "            prop_cycle: unknown\n",
      "            rasterization_zorder: float or None\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            title: str\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            xbound: unknown\n",
      "            xlabel: str\n",
      "            xlim: (bottom: float, top: float)\n",
      "            xmargin: float greater than -0.5\n",
      "            xscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            xticklabels: unknown\n",
      "            xticks: unknown\n",
      "            ybound: unknown\n",
      "            ylabel: str\n",
      "            ylim: (bottom: float, top: float)\n",
      "            ymargin: float greater than -0.5\n",
      "            yscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            yticklabels: unknown\n",
      "            yticks: unknown\n",
      "            zorder: float\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Creating a new Axes will delete any pre-existing Axes that\n",
      "        overlaps with it beyond sharing a boundary::\n",
      "        \n",
      "            import matplotlib.pyplot as plt\n",
      "            # plot a line, implicitly creating a subplot(111)\n",
      "            plt.plot([1, 2, 3])\n",
      "            # now create a subplot which represents the top plot of a grid\n",
      "            # with 2 rows and 1 column. Since this subplot will overlap the\n",
      "            # first, the plot (and its axes) previously created, will be removed\n",
      "            plt.subplot(211)\n",
      "        \n",
      "        If you do not want this behavior, use the `.Figure.add_subplot` method\n",
      "        or the `.pyplot.axes` function instead.\n",
      "        \n",
      "        If no *kwargs* are passed and there exists an Axes in the location\n",
      "        specified by *args* then that Axes will be returned rather than a new\n",
      "        Axes being created.\n",
      "        \n",
      "        If *kwargs* are passed and there exists an Axes in the location\n",
      "        specified by *args*, the projection type is the same, and the\n",
      "        *kwargs* match with the existing Axes, then the existing Axes is\n",
      "        returned.  Otherwise a new Axes is created with the specified\n",
      "        parameters.  We save a reference to the *kwargs* which we use\n",
      "        for this comparison.  If any of the values in *kwargs* are\n",
      "        mutable we will not detect the case where they are mutated.\n",
      "        In these cases we suggest using `.Figure.add_subplot` and the\n",
      "        explicit Axes API rather than the implicit pyplot API.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .Figure.add_subplot\n",
      "        .pyplot.subplots\n",
      "        .pyplot.axes\n",
      "        .Figure.subplots\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            plt.subplot(221)\n",
      "        \n",
      "            # equivalent but more general\n",
      "            ax1 = plt.subplot(2, 2, 1)\n",
      "        \n",
      "            # add a subplot with no frame\n",
      "            ax2 = plt.subplot(222, frameon=False)\n",
      "        \n",
      "            # add a polar subplot\n",
      "            plt.subplot(223, projection='polar')\n",
      "        \n",
      "            # add a red subplot that shares the x-axis with ax1\n",
      "            plt.subplot(224, sharex=ax1, facecolor='red')\n",
      "        \n",
      "            # delete ax2 from the figure\n",
      "            plt.delaxes(ax2)\n",
      "        \n",
      "            # add ax2 to the figure again\n",
      "            plt.subplot(ax2)\n",
      "        \n",
      "            # make the first axes \"current\" again\n",
      "            plt.subplot(221)\n",
      "    \n",
      "    subplot2grid(shape, loc, rowspan=1, colspan=1, fig=None, **kwargs)\n",
      "        Create a subplot at a specific location inside a regular grid.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        shape : (int, int)\n",
      "            Number of rows and of columns of the grid in which to place axis.\n",
      "        loc : (int, int)\n",
      "            Row number and column number of the axis location within the grid.\n",
      "        rowspan : int, default: 1\n",
      "            Number of rows for the axis to span downwards.\n",
      "        colspan : int, default: 1\n",
      "            Number of columns for the axis to span to the right.\n",
      "        fig : `.Figure`, optional\n",
      "            Figure to place the subplot in. Defaults to the current figure.\n",
      "        **kwargs\n",
      "            Additional keyword arguments are handed to `~.Figure.add_subplot`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.axes.SubplotBase`, or another subclass of `~.axes.Axes`\n",
      "        \n",
      "            The axes of the subplot.  The returned axes base class depends on the\n",
      "            projection used.  It is `~.axes.Axes` if rectilinear projection is used\n",
      "            and `.projections.polar.PolarAxes` if polar projection is used.  The\n",
      "            returned axes is then a subplot subclass of the base class.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The following call ::\n",
      "        \n",
      "            ax = subplot2grid((nrows, ncols), (row, col), rowspan, colspan)\n",
      "        \n",
      "        is identical to ::\n",
      "        \n",
      "            fig = gcf()\n",
      "            gs = fig.add_gridspec(nrows, ncols)\n",
      "            ax = fig.add_subplot(gs[row:row+rowspan, col:col+colspan])\n",
      "    \n",
      "    subplot_mosaic(mosaic, *, subplot_kw=None, gridspec_kw=None, empty_sentinel='.', **fig_kw)\n",
      "        Build a layout of Axes based on ASCII art or nested lists.\n",
      "        \n",
      "        This is a helper function to build complex GridSpec layouts visually.\n",
      "        \n",
      "        .. note ::\n",
      "        \n",
      "           This API is provisional and may be revised in the future based on\n",
      "           early user feedback.\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mosaic : list of list of {hashable or nested} or str\n",
      "        \n",
      "            A visual layout of how you want your Axes to be arranged\n",
      "            labeled as strings.  For example ::\n",
      "        \n",
      "               x = [['A panel', 'A panel', 'edge'],\n",
      "                    ['C panel', '.',       'edge']]\n",
      "        \n",
      "            Produces 4 axes:\n",
      "        \n",
      "            - 'A panel' which is 1 row high and spans the first two columns\n",
      "            - 'edge' which is 2 rows high and is on the right edge\n",
      "            - 'C panel' which in 1 row and 1 column wide in the bottom left\n",
      "            - a blank space 1 row and 1 column wide in the bottom center\n",
      "        \n",
      "            Any of the entries in the layout can be a list of lists\n",
      "            of the same form to create nested layouts.\n",
      "        \n",
      "            If input is a str, then it must be of the form ::\n",
      "        \n",
      "              '''\n",
      "              AAE\n",
      "              C.E\n",
      "              '''\n",
      "        \n",
      "            where each character is a column and each line is a row.\n",
      "            This only allows only single character Axes labels and does\n",
      "            not allow nesting but is very terse.\n",
      "        \n",
      "        subplot_kw : dict, optional\n",
      "            Dictionary with keywords passed to the `.Figure.add_subplot` call\n",
      "            used to create each subplot.\n",
      "        \n",
      "        gridspec_kw : dict, optional\n",
      "            Dictionary with keywords passed to the `.GridSpec` constructor used\n",
      "            to create the grid the subplots are placed on.\n",
      "        \n",
      "        empty_sentinel : object, optional\n",
      "            Entry in the layout to mean \"leave this space empty\".  Defaults\n",
      "            to ``'.'``. Note, if *layout* is a string, it is processed via\n",
      "            `inspect.cleandoc` to remove leading white space, which may\n",
      "            interfere with using white-space as the empty sentinel.\n",
      "        \n",
      "        **fig_kw\n",
      "            All additional keyword arguments are passed to the\n",
      "            `.pyplot.figure` call.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        fig : `~.figure.Figure`\n",
      "           The new figure\n",
      "        \n",
      "        dict[label, Axes]\n",
      "           A dictionary mapping the labels to the Axes objects.  The order of\n",
      "           the axes is left-to-right and top-to-bottom of their position in the\n",
      "           total layout.\n",
      "    \n",
      "    subplot_tool(targetfig=None)\n",
      "        Launch a subplot tool window for a figure.\n",
      "        \n",
      "        A `matplotlib.widgets.SubplotTool` instance is returned. You must maintain\n",
      "        a reference to the instance to keep the associated callbacks alive.\n",
      "    \n",
      "    subplots(nrows=1, ncols=1, *, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw)\n",
      "        Create a figure and a set of subplots.\n",
      "        \n",
      "        This utility wrapper makes it convenient to create common layouts of\n",
      "        subplots, including the enclosing figure object, in a single call.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        nrows, ncols : int, default: 1\n",
      "            Number of rows/columns of the subplot grid.\n",
      "        \n",
      "        sharex, sharey : bool or {'none', 'all', 'row', 'col'}, default: False\n",
      "            Controls sharing of properties among x (*sharex*) or y (*sharey*)\n",
      "            axes:\n",
      "        \n",
      "            - True or 'all': x- or y-axis will be shared among all subplots.\n",
      "            - False or 'none': each subplot x- or y-axis will be independent.\n",
      "            - 'row': each subplot row will share an x- or y-axis.\n",
      "            - 'col': each subplot column will share an x- or y-axis.\n",
      "        \n",
      "            When subplots have a shared x-axis along a column, only the x tick\n",
      "            labels of the bottom subplot are created. Similarly, when subplots\n",
      "            have a shared y-axis along a row, only the y tick labels of the first\n",
      "            column subplot are created. To later turn other subplots' ticklabels\n",
      "            on, use `~matplotlib.axes.Axes.tick_params`.\n",
      "        \n",
      "            When subplots have a shared axis that has units, calling\n",
      "            `~matplotlib.axis.Axis.set_units` will update each axis with the\n",
      "            new units.\n",
      "        \n",
      "        squeeze : bool, default: True\n",
      "            - If True, extra dimensions are squeezed out from the returned\n",
      "              array of `~matplotlib.axes.Axes`:\n",
      "        \n",
      "              - if only one subplot is constructed (nrows=ncols=1), the\n",
      "                resulting single Axes object is returned as a scalar.\n",
      "              - for Nx1 or 1xM subplots, the returned object is a 1D numpy\n",
      "                object array of Axes objects.\n",
      "              - for NxM, subplots with N>1 and M>1 are returned as a 2D array.\n",
      "        \n",
      "            - If False, no squeezing at all is done: the returned Axes object is\n",
      "              always a 2D array containing Axes instances, even if it ends up\n",
      "              being 1x1.\n",
      "        \n",
      "        subplot_kw : dict, optional\n",
      "            Dict with keywords passed to the\n",
      "            `~matplotlib.figure.Figure.add_subplot` call used to create each\n",
      "            subplot.\n",
      "        \n",
      "        gridspec_kw : dict, optional\n",
      "            Dict with keywords passed to the `~matplotlib.gridspec.GridSpec`\n",
      "            constructor used to create the grid the subplots are placed on.\n",
      "        \n",
      "        **fig_kw\n",
      "            All additional keyword arguments are passed to the\n",
      "            `.pyplot.figure` call.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        fig : `~.figure.Figure`\n",
      "        \n",
      "        ax : `.axes.Axes` or array of Axes\n",
      "            *ax* can be either a single `~matplotlib.axes.Axes` object or an\n",
      "            array of Axes objects if more than one subplot was created.  The\n",
      "            dimensions of the resulting array can be controlled with the squeeze\n",
      "            keyword, see above.\n",
      "        \n",
      "            Typical idioms for handling the return value are::\n",
      "        \n",
      "                # using the variable ax for single a Axes\n",
      "                fig, ax = plt.subplots()\n",
      "        \n",
      "                # using the variable axs for multiple Axes\n",
      "                fig, axs = plt.subplots(2, 2)\n",
      "        \n",
      "                # using tuple unpacking for multiple Axes\n",
      "                fig, (ax1, ax2) = plt.subplots(1, 2)\n",
      "                fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)\n",
      "        \n",
      "            The names ``ax`` and pluralized ``axs`` are preferred over ``axes``\n",
      "            because for the latter it's not clear if it refers to a single\n",
      "            `~.axes.Axes` instance or a collection of these.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .pyplot.figure\n",
      "        .pyplot.subplot\n",
      "        .pyplot.axes\n",
      "        .Figure.subplots\n",
      "        .Figure.add_subplot\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            # First create some toy data:\n",
      "            x = np.linspace(0, 2*np.pi, 400)\n",
      "            y = np.sin(x**2)\n",
      "        \n",
      "            # Create just a figure and only one subplot\n",
      "            fig, ax = plt.subplots()\n",
      "            ax.plot(x, y)\n",
      "            ax.set_title('Simple plot')\n",
      "        \n",
      "            # Create two subplots and unpack the output array immediately\n",
      "            f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
      "            ax1.plot(x, y)\n",
      "            ax1.set_title('Sharing Y axis')\n",
      "            ax2.scatter(x, y)\n",
      "        \n",
      "            # Create four polar axes and access them through the returned array\n",
      "            fig, axs = plt.subplots(2, 2, subplot_kw=dict(projection=\"polar\"))\n",
      "            axs[0, 0].plot(x, y)\n",
      "            axs[1, 1].scatter(x, y)\n",
      "        \n",
      "            # Share a X axis with each column of subplots\n",
      "            plt.subplots(2, 2, sharex='col')\n",
      "        \n",
      "            # Share a Y axis with each row of subplots\n",
      "            plt.subplots(2, 2, sharey='row')\n",
      "        \n",
      "            # Share both X and Y axes with all subplots\n",
      "            plt.subplots(2, 2, sharex='all', sharey='all')\n",
      "        \n",
      "            # Note that this is the same as\n",
      "            plt.subplots(2, 2, sharex=True, sharey=True)\n",
      "        \n",
      "            # Create figure number 10 with a single subplot\n",
      "            # and clears it if it already exists.\n",
      "            fig, ax = plt.subplots(num=10, clear=True)\n",
      "    \n",
      "    subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=None)\n",
      "        Adjust the subplot layout parameters.\n",
      "        \n",
      "        Unset parameters are left unmodified; initial values are given by\n",
      "        :rc:`figure.subplot.[name]`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        left : float, optional\n",
      "            The position of the left edge of the subplots,\n",
      "            as a fraction of the figure width.\n",
      "        right : float, optional\n",
      "            The position of the right edge of the subplots,\n",
      "            as a fraction of the figure width.\n",
      "        bottom : float, optional\n",
      "            The position of the bottom edge of the subplots,\n",
      "            as a fraction of the figure height.\n",
      "        top : float, optional\n",
      "            The position of the top edge of the subplots,\n",
      "            as a fraction of the figure height.\n",
      "        wspace : float, optional\n",
      "            The width of the padding between subplots,\n",
      "            as a fraction of the average Axes width.\n",
      "        hspace : float, optional\n",
      "            The height of the padding between subplots,\n",
      "            as a fraction of the average Axes height.\n",
      "    \n",
      "    summer()\n",
      "        Set the colormap to 'summer'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    suptitle(t, **kwargs)\n",
      "        Add a centered suptitle to the figure.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        t : str\n",
      "            The suptitle text.\n",
      "        x : float, default: 0.5\n",
      "            The x location of the text in figure coordinates.\n",
      "        y : float, default: 0.98\n",
      "            The y location of the text in figure coordinates.\n",
      "        horizontalalignment, ha : {'center', 'left', 'right'}, default: center\n",
      "            The horizontal alignment of the text relative to (*x*, *y*).\n",
      "        verticalalignment, va : {'top', 'center', 'bottom', 'baseline'}, default: top\n",
      "            The vertical alignment of the text relative to (*x*, *y*).\n",
      "        fontsize, size : default: :rc:`figure.titlesize`\n",
      "            The font size of the text. See `.Text.set_size` for possible\n",
      "            values.\n",
      "        fontweight, weight : default: :rc:`figure.titleweight`\n",
      "            The font weight of the text. See `.Text.set_weight` for possible\n",
      "            values.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        text\n",
      "            The `.Text` instance of the suptitle.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        fontproperties : None or dict, optional\n",
      "            A dict of font properties. If *fontproperties* is given the\n",
      "            default values for font size and weight are taken from the\n",
      "            `.FontProperties` defaults. :rc:`figure.titlesize` and\n",
      "            :rc:`figure.titleweight` are ignored in this case.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional kwargs are `matplotlib.text.Text` properties.\n",
      "    \n",
      "    switch_backend(newbackend)\n",
      "        Close all open figures and set the Matplotlib backend.\n",
      "        \n",
      "        The argument is case-insensitive.  Switching to an interactive backend is\n",
      "        possible only if no event loop for another interactive backend has started.\n",
      "        Switching to and from non-interactive backends is always possible.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        newbackend : str\n",
      "            The name of the backend to use.\n",
      "    \n",
      "    table(cellText=None, cellColours=None, cellLoc='right', colWidths=None, rowLabels=None, rowColours=None, rowLoc='left', colLabels=None, colColours=None, colLoc='center', loc='bottom', bbox=None, edges='closed', **kwargs)\n",
      "        Add a table to an `~.axes.Axes`.\n",
      "        \n",
      "        At least one of *cellText* or *cellColours* must be specified. These\n",
      "        parameters must be 2D lists, in which the outer lists define the rows and\n",
      "        the inner list define the column values per row. Each row must have the\n",
      "        same number of elements.\n",
      "        \n",
      "        The table can optionally have row and column headers, which are configured\n",
      "        using *rowLabels*, *rowColours*, *rowLoc* and *colLabels*, *colColours*,\n",
      "        *colLoc* respectively.\n",
      "        \n",
      "        For finer grained control over tables, use the `.Table` class and add it to\n",
      "        the axes with `.Axes.add_table`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        cellText : 2D list of str, optional\n",
      "            The texts to place into the table cells.\n",
      "        \n",
      "            *Note*: Line breaks in the strings are currently not accounted for and\n",
      "            will result in the text exceeding the cell boundaries.\n",
      "        \n",
      "        cellColours : 2D list of colors, optional\n",
      "            The background colors of the cells.\n",
      "        \n",
      "        cellLoc : {'left', 'center', 'right'}, default: 'right'\n",
      "            The alignment of the text within the cells.\n",
      "        \n",
      "        colWidths : list of float, optional\n",
      "            The column widths in units of the axes. If not given, all columns will\n",
      "            have a width of *1 / ncols*.\n",
      "        \n",
      "        rowLabels : list of str, optional\n",
      "            The text of the row header cells.\n",
      "        \n",
      "        rowColours : list of colors, optional\n",
      "            The colors of the row header cells.\n",
      "        \n",
      "        rowLoc : {'left', 'center', 'right'}, default: 'left'\n",
      "            The text alignment of the row header cells.\n",
      "        \n",
      "        colLabels : list of str, optional\n",
      "            The text of the column header cells.\n",
      "        \n",
      "        colColours : list of colors, optional\n",
      "            The colors of the column header cells.\n",
      "        \n",
      "        colLoc : {'left', 'center', 'right'}, default: 'left'\n",
      "            The text alignment of the column header cells.\n",
      "        \n",
      "        loc : str, optional\n",
      "            The position of the cell with respect to *ax*. This must be one of\n",
      "            the `~.Table.codes`.\n",
      "        \n",
      "        bbox : `.Bbox`, optional\n",
      "            A bounding box to draw the table into. If this is not *None*, this\n",
      "            overrides *loc*.\n",
      "        \n",
      "        edges : substring of 'BRTL' or {'open', 'closed', 'horizontal', 'vertical'}\n",
      "            The cell edges to be drawn with a line. See also\n",
      "            `~.Cell.visible_edges`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.table.Table`\n",
      "            The created table.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            `.Table` properties.\n",
      "        \n",
      "        Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            contains: unknown\n",
      "            figure: `.Figure`\n",
      "            fontsize: float\n",
      "            gid: str\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            rasterized: bool\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            transform: `.Transform`\n",
      "            url: str\n",
      "            visible: bool\n",
      "            zorder: float\n",
      "    \n",
      "    text(x, y, s, fontdict=None, **kwargs)\n",
      "        Add text to the Axes.\n",
      "        \n",
      "        Add the text *s* to the Axes at location *x*, *y* in data coordinates.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : float\n",
      "            The position to place the text. By default, this is in data\n",
      "            coordinates. The coordinate system can be changed using the\n",
      "            *transform* parameter.\n",
      "        \n",
      "        s : str\n",
      "            The text.\n",
      "        \n",
      "        fontdict : dict, default: None\n",
      "            A dictionary to override the default text properties. If fontdict\n",
      "            is None, the defaults are determined by `.rcParams`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.Text`\n",
      "            The created `.Text` instance.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.text.Text` properties.\n",
      "            Other miscellaneous text parameters.\n",
      "        \n",
      "            Properties:\n",
      "            agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "            alpha: scalar or None\n",
      "            animated: bool\n",
      "            backgroundcolor: color\n",
      "            bbox: dict with properties for `.patches.FancyBboxPatch`\n",
      "            clip_box: `.Bbox`\n",
      "            clip_on: bool\n",
      "            clip_path: Patch or (Path, Transform) or None\n",
      "            color or c: color\n",
      "            contains: unknown\n",
      "            figure: `.Figure`\n",
      "            fontfamily or family: {FONTNAME, 'serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'}\n",
      "            fontproperties or font or font_properties: `.font_manager.FontProperties` or `str` or `pathlib.Path`\n",
      "            fontsize or size: float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "            fontstretch or stretch: {a numeric value in range 0-1000, 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}\n",
      "            fontstyle or style: {'normal', 'italic', 'oblique'}\n",
      "            fontvariant or variant: {'normal', 'small-caps'}\n",
      "            fontweight or weight: {a numeric value in range 0-1000, 'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}\n",
      "            gid: str\n",
      "            horizontalalignment or ha: {'center', 'right', 'left'}\n",
      "            in_layout: bool\n",
      "            label: object\n",
      "            linespacing: float (multiple of font size)\n",
      "            math_fontfamily: str\n",
      "            multialignment or ma: {'left', 'right', 'center'}\n",
      "            path_effects: `.AbstractPathEffect`\n",
      "            picker: None or bool or float or callable\n",
      "            position: (float, float)\n",
      "            rasterized: bool\n",
      "            rotation: float or {'vertical', 'horizontal'}\n",
      "            rotation_mode: {None, 'default', 'anchor'}\n",
      "            sketch_params: (scale: float, length: float, randomness: float)\n",
      "            snap: bool or None\n",
      "            text: object\n",
      "            transform: `.Transform`\n",
      "            transform_rotates_text: bool\n",
      "            url: str\n",
      "            usetex: bool or None\n",
      "            verticalalignment or va: {'center', 'top', 'bottom', 'baseline', 'center_baseline'}\n",
      "            visible: bool\n",
      "            wrap: bool\n",
      "            x: float\n",
      "            y: float\n",
      "            zorder: float\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Individual keyword arguments can be used to override any given\n",
      "        parameter::\n",
      "        \n",
      "            >>> text(x, y, s, fontsize=12)\n",
      "        \n",
      "        The default transform specifies that text is in data coords,\n",
      "        alternatively, you can specify text in axis coords ((0, 0) is\n",
      "        lower-left and (1, 1) is upper-right).  The example below places\n",
      "        text in the center of the Axes::\n",
      "        \n",
      "            >>> text(0.5, 0.5, 'matplotlib', horizontalalignment='center',\n",
      "            ...      verticalalignment='center', transform=ax.transAxes)\n",
      "        \n",
      "        You can put a rectangular box around the text instance (e.g., to\n",
      "        set a background color) by using the keyword *bbox*.  *bbox* is\n",
      "        a dictionary of `~matplotlib.patches.Rectangle`\n",
      "        properties.  For example::\n",
      "        \n",
      "            >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))\n",
      "    \n",
      "    thetagrids(angles=None, labels=None, fmt=None, **kwargs)\n",
      "        Get or set the theta gridlines on the current polar plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "         lines, labels = thetagrids()\n",
      "         lines, labels = thetagrids(angles, labels=None, fmt=None, **kwargs)\n",
      "        \n",
      "        When called with no arguments, `.thetagrids` simply returns the tuple\n",
      "        (*lines*, *labels*). When called with arguments, the labels will\n",
      "        appear at the specified angles.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        angles : tuple with floats, degrees\n",
      "            The angles of the theta gridlines.\n",
      "        \n",
      "        labels : tuple with strings or None\n",
      "            The labels to use at each radial gridline. The\n",
      "            `.projections.polar.ThetaFormatter` will be used if None.\n",
      "        \n",
      "        fmt : str or None\n",
      "            Format string used in `matplotlib.ticker.FormatStrFormatter`.\n",
      "            For example '%f'. Note that the angle in radians will be used.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : list of `.lines.Line2D`\n",
      "            The theta gridlines.\n",
      "        \n",
      "        labels : list of `.text.Text`\n",
      "            The tick labels.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            *kwargs* are optional `~.Text` properties for the labels.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        .pyplot.rgrids\n",
      "        .projections.polar.PolarAxes.set_thetagrids\n",
      "        .Axis.get_gridlines\n",
      "        .Axis.get_ticklabels\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "          # set the locations of the angular gridlines\n",
      "          lines, labels = thetagrids(range(45, 360, 90))\n",
      "        \n",
      "          # set the locations and labels of the angular gridlines\n",
      "          lines, labels = thetagrids(range(45, 360, 90), ('NE', 'NW', 'SW', 'SE'))\n",
      "    \n",
      "    tick_params(axis='both', **kwargs)\n",
      "        Change the appearance of ticks, tick labels, and gridlines.\n",
      "        \n",
      "        Tick properties that are not explicitly set using the keyword\n",
      "        arguments remain unchanged unless *reset* is True.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        axis : {'x', 'y', 'both'}, default: 'both'\n",
      "            The axis to which the parameters are applied.\n",
      "        which : {'major', 'minor', 'both'}, default: 'major'\n",
      "            The group of ticks to which the parameters are applied.\n",
      "        reset : bool, default: False\n",
      "            Whether to reset the ticks to defaults before updating them.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        direction : {'in', 'out', 'inout'}\n",
      "            Puts ticks inside the axes, outside the axes, or both.\n",
      "        length : float\n",
      "            Tick length in points.\n",
      "        width : float\n",
      "            Tick width in points.\n",
      "        color : color\n",
      "            Tick color.\n",
      "        pad : float\n",
      "            Distance in points between tick and label.\n",
      "        labelsize : float or str\n",
      "            Tick label font size in points or as a string (e.g., 'large').\n",
      "        labelcolor : color\n",
      "            Tick label color.\n",
      "        colors : color\n",
      "            Tick color and label color.\n",
      "        zorder : float\n",
      "            Tick and label zorder.\n",
      "        bottom, top, left, right : bool\n",
      "            Whether to draw the respective ticks.\n",
      "        labelbottom, labeltop, labelleft, labelright : bool\n",
      "            Whether to draw the respective tick labels.\n",
      "        labelrotation : float\n",
      "            Tick label rotation\n",
      "        grid_color : color\n",
      "            Gridline color.\n",
      "        grid_alpha : float\n",
      "            Transparency of gridlines: 0 (transparent) to 1 (opaque).\n",
      "        grid_linewidth : float\n",
      "            Width of gridlines in points.\n",
      "        grid_linestyle : str\n",
      "            Any valid `.Line2D` line style spec.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        ::\n",
      "        \n",
      "            ax.tick_params(direction='out', length=6, width=2, colors='r',\n",
      "                           grid_color='r', grid_alpha=0.5)\n",
      "        \n",
      "        This will make all major ticks be red, pointing out of the box,\n",
      "        and with dimensions 6 points by 2 points.  Tick labels will\n",
      "        also be red.  Gridlines will be red and translucent.\n",
      "    \n",
      "    ticklabel_format(*, axis='both', style='', scilimits=None, useOffset=None, useLocale=None, useMathText=None)\n",
      "        Configure the `.ScalarFormatter` used by default for linear axes.\n",
      "        \n",
      "        If a parameter is not set, the corresponding property of the formatter\n",
      "        is left unchanged.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        axis : {'x', 'y', 'both'}, default: 'both'\n",
      "            The axes to configure.  Only major ticks are affected.\n",
      "        \n",
      "        style : {'sci', 'scientific', 'plain'}\n",
      "            Whether to use scientific notation.\n",
      "            The formatter default is to use scientific notation.\n",
      "        \n",
      "        scilimits : pair of ints (m, n)\n",
      "            Scientific notation is used only for numbers outside the range\n",
      "            10\\ :sup:`m` to 10\\ :sup:`n` (and only if the formatter is\n",
      "            configured to use scientific notation at all).  Use (0, 0) to\n",
      "            include all numbers.  Use (m, m) where m != 0 to fix the order of\n",
      "            magnitude to 10\\ :sup:`m`.\n",
      "            The formatter default is :rc:`axes.formatter.limits`.\n",
      "        \n",
      "        useOffset : bool or float\n",
      "            If True, the offset is calculated as needed.\n",
      "            If False, no offset is used.\n",
      "            If a numeric value, it sets the offset.\n",
      "            The formatter default is :rc:`axes.formatter.useoffset`.\n",
      "        \n",
      "        useLocale : bool\n",
      "            Whether to format the number using the current locale or using the\n",
      "            C (English) locale.  This affects e.g. the decimal separator.  The\n",
      "            formatter default is :rc:`axes.formatter.use_locale`.\n",
      "        \n",
      "        useMathText : bool\n",
      "            Render the offset and scientific notation in mathtext.\n",
      "            The formatter default is :rc:`axes.formatter.use_mathtext`.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        AttributeError\n",
      "            If the current formatter is not a `.ScalarFormatter`.\n",
      "    \n",
      "    tight_layout(*, pad=1.08, h_pad=None, w_pad=None, rect=None)\n",
      "        Adjust the padding between and around subplots.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        pad : float, default: 1.08\n",
      "            Padding between the figure edge and the edges of subplots,\n",
      "            as a fraction of the font size.\n",
      "        h_pad, w_pad : float, default: *pad*\n",
      "            Padding (height/width) between edges of adjacent subplots,\n",
      "            as a fraction of the font size.\n",
      "        rect : tuple (left, bottom, right, top), default: (0, 0, 1, 1)\n",
      "            A rectangle in normalized figure coordinates into which the whole\n",
      "            subplots area (including labels) will fit.\n",
      "    \n",
      "    title(label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs)\n",
      "        Set a title for the Axes.\n",
      "        \n",
      "        Set one of the three available Axes titles. The available titles\n",
      "        are positioned above the Axes in the center, flush with the left\n",
      "        edge, and flush with the right edge.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        label : str\n",
      "            Text to use for the title\n",
      "        \n",
      "        fontdict : dict\n",
      "            A dictionary controlling the appearance of the title text,\n",
      "            the default *fontdict* is::\n",
      "        \n",
      "               {'fontsize': rcParams['axes.titlesize'],\n",
      "                'fontweight': rcParams['axes.titleweight'],\n",
      "                'color': rcParams['axes.titlecolor'],\n",
      "                'verticalalignment': 'baseline',\n",
      "                'horizontalalignment': loc}\n",
      "        \n",
      "        loc : {'center', 'left', 'right'}, default: :rc:`axes.titlelocation`\n",
      "            Which title to set.\n",
      "        \n",
      "        y : float, default: :rc:`axes.titley`\n",
      "            Vertical Axes loation for the title (1.0 is the top).  If\n",
      "            None (the default), y is determined automatically to avoid\n",
      "            decorators on the Axes.\n",
      "        \n",
      "        pad : float, default: :rc:`axes.titlepad`\n",
      "            The offset of the title from the top of the Axes, in points.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.Text`\n",
      "            The matplotlib text instance representing the title\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `.Text` properties\n",
      "            Other keyword arguments are text properties, see `.Text` for a list\n",
      "            of valid text properties.\n",
      "    \n",
      "    tricontour(*args, **kwargs)\n",
      "        Draw contour lines on an unstructured triangular grid.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either ::\n",
      "        \n",
      "            tricontour(triangulation, ...)\n",
      "        \n",
      "        where *triangulation* is a `.Triangulation` object, or ::\n",
      "        \n",
      "            tricontour(x, y, ...)\n",
      "            tricontour(x, y, triangles, ...)\n",
      "            tricontour(x, y, triangles=triangles, ...)\n",
      "            tricontour(x, y, mask=mask, ...)\n",
      "            tricontour(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a `.Triangulation` object will be created.  See that class'\n",
      "        docstring for an explanation of these cases.\n",
      "        \n",
      "        The remaining arguments may be::\n",
      "        \n",
      "            tricontour(..., Z)\n",
      "        \n",
      "        where *Z* is the array of values to contour, one per point in the\n",
      "        triangulation.  The level values are chosen automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(..., Z, levels)\n",
      "        \n",
      "        contour up to *levels+1* automatically chosen contour levels (*levels*\n",
      "        intervals).\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(..., Z, levels)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *levels*, which must\n",
      "        be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword arguments to control colors, linewidth, origin, cmap ... see below\n",
      "        for more details.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        triangulation : `.Triangulation`, optional\n",
      "            The unstructured triangular grid.\n",
      "        \n",
      "            If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.\n",
      "        \n",
      "        x, y : array-like, optional\n",
      "            The coordinates of the values in *Z*.\n",
      "        \n",
      "        triangles : (ntri, 3) array-like of int, optional\n",
      "            For each triangle, the indices of the three points that make up the\n",
      "            triangle, ordered in an anticlockwise manner.  If not specified, the\n",
      "            Delaunay triangulation is calculated.\n",
      "        \n",
      "        mask : (ntri,) array-like of bool, optional\n",
      "            Which triangles are masked out.\n",
      "        \n",
      "        Z : 2D array-like\n",
      "            The height values over which the contour is drawn.\n",
      "        \n",
      "        levels : int or array-like, optional\n",
      "            Determines the number and positions of the contour lines / regions.\n",
      "        \n",
      "            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to\n",
      "            automatically choose no more than *n+1* \"nice\" contour levels between\n",
      "            *vmin* and *vmax*.\n",
      "        \n",
      "            If array-like, draw contour lines at the specified levels.  The values must\n",
      "            be in increasing order.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.tri.TriContourSet`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        colors : color string or sequence of colors, optional\n",
      "            The colors of the levels, i.e., the contour lines.\n",
      "        \n",
      "            The sequence is cycled for the levels in ascending order. If the sequence\n",
      "            is shorter than the number of levels, it's repeated.\n",
      "        \n",
      "            As a shortcut, single color strings may be used in place of one-element\n",
      "            lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the\n",
      "            same color. This shortcut does only work for color strings, not for other\n",
      "            ways of specifying colors.\n",
      "        \n",
      "            By default (value *None*), the colormap specified by *cmap* will be used.\n",
      "        \n",
      "        alpha : float, default: 1\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      "            A `.Colormap` instance or registered colormap name. The colormap maps the\n",
      "            level values to colors.\n",
      "        \n",
      "            If both *colors* and *cmap* are given, an error is raised.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            If a colormap is used, the `.Normalize` instance scales the level values to\n",
      "            the canonical colormap range [0, 1] for mapping to colors. If not given,\n",
      "            the default linear scaling is used.\n",
      "        \n",
      "        vmin, vmax : float, optional\n",
      "            If not *None*, either or both of these values will be supplied to\n",
      "            the `.Normalize` instance, overriding the default color scaling\n",
      "            based on *levels*.\n",
      "        \n",
      "        origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      "            Determines the orientation and exact position of *Z* by specifying the\n",
      "            position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.\n",
      "        \n",
      "            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      "            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      "            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.\n",
      "            - 'image': Use the value from :rc:`image.origin`.\n",
      "        \n",
      "        extent : (x0, x1, y0, y1), optional\n",
      "            If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it\n",
      "            gives the outer pixel boundaries. In this case, the position of Z[0, 0] is\n",
      "            the center of the pixel, not a corner. If *origin* is *None*, then\n",
      "            (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position\n",
      "            of Z[-1, -1].\n",
      "        \n",
      "            This argument is ignored if *X* and *Y* are specified in the call to\n",
      "            contour.\n",
      "        \n",
      "        locator : ticker.Locator subclass, optional\n",
      "            The locator is used to determine the contour levels if they are not given\n",
      "            explicitly via *levels*.\n",
      "            Defaults to `~.ticker.MaxNLocator`.\n",
      "        \n",
      "        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      "            Determines the ``tricontour``-coloring of values that are outside the\n",
      "            *levels* range.\n",
      "        \n",
      "            If 'neither', values outside the *levels* range are not colored.  If 'min',\n",
      "            'max' or 'both', color the values below, above or below and above the\n",
      "            *levels* range.\n",
      "        \n",
      "            Values below ``min(levels)`` and above ``max(levels)`` are mapped to the\n",
      "            under/over values of the `.Colormap`. Note that most colormaps do not have\n",
      "            dedicated colors for these by default, so that the over and under values\n",
      "            are the edge values of the colormap.  You may want to set these values\n",
      "            explicitly using `.Colormap.set_under` and `.Colormap.set_over`.\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "                An existing `.TriContourSet` does not get notified if properties of its\n",
      "                colormap are changed. Therefore, an explicit call to\n",
      "                `.ContourSet.changed()` is needed after modifying the colormap. The\n",
      "                explicit call can be left out, if a colorbar is assigned to the\n",
      "                `.TriContourSet` because it internally calls `.ContourSet.changed()`.\n",
      "        \n",
      "        xunits, yunits : registered units, optional\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        antialiased : bool, optional\n",
      "            Enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from :rc:`lines.antialiased`.\n",
      "        \n",
      "        linewidths : float or array-like, default: :rc:`contour.linewidth`\n",
      "            The line width of the contour lines.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a sequence, the levels in ascending order will be plotted with\n",
      "            the linewidths in the order specified.\n",
      "        \n",
      "            If None, this falls back to :rc:`lines.linewidth`.\n",
      "        \n",
      "        linestyles : {*None*, 'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      "            If *linestyles* is *None*, the default is 'solid' unless the lines are\n",
      "            monochrome.  In that case, negative contours will take their linestyle\n",
      "            from :rc:`contour.negative_linestyle` setting.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings specifying a\n",
      "            set of linestyles to be used. If this iterable is shorter than the\n",
      "            number of contour levels it will be repeated as necessary.\n",
      "    \n",
      "    tricontourf(*args, **kwargs)\n",
      "        Draw contour regions on an unstructured triangular grid.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either ::\n",
      "        \n",
      "            tricontourf(triangulation, ...)\n",
      "        \n",
      "        where *triangulation* is a `.Triangulation` object, or ::\n",
      "        \n",
      "            tricontourf(x, y, ...)\n",
      "            tricontourf(x, y, triangles, ...)\n",
      "            tricontourf(x, y, triangles=triangles, ...)\n",
      "            tricontourf(x, y, mask=mask, ...)\n",
      "            tricontourf(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a `.Triangulation` object will be created.  See that class'\n",
      "        docstring for an explanation of these cases.\n",
      "        \n",
      "        The remaining arguments may be::\n",
      "        \n",
      "            tricontourf(..., Z)\n",
      "        \n",
      "        where *Z* is the array of values to contour, one per point in the\n",
      "        triangulation.  The level values are chosen automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontourf(..., Z, levels)\n",
      "        \n",
      "        contour up to *levels+1* automatically chosen contour levels (*levels*\n",
      "        intervals).\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontourf(..., Z, levels)\n",
      "        \n",
      "        draw contour regions at the values specified in sequence *levels*, which must\n",
      "        be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontourf(Z, **kwargs)\n",
      "        \n",
      "        Use keyword arguments to control colors, linewidth, origin, cmap ... see below\n",
      "        for more details.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        triangulation : `.Triangulation`, optional\n",
      "            The unstructured triangular grid.\n",
      "        \n",
      "            If specified, then *x*, *y*, *triangles*, and *mask* are not accepted.\n",
      "        \n",
      "        x, y : array-like, optional\n",
      "            The coordinates of the values in *Z*.\n",
      "        \n",
      "        triangles : (ntri, 3) array-like of int, optional\n",
      "            For each triangle, the indices of the three points that make up the\n",
      "            triangle, ordered in an anticlockwise manner.  If not specified, the\n",
      "            Delaunay triangulation is calculated.\n",
      "        \n",
      "        mask : (ntri,) array-like of bool, optional\n",
      "            Which triangles are masked out.\n",
      "        \n",
      "        Z : 2D array-like\n",
      "            The height values over which the contour is drawn.\n",
      "        \n",
      "        levels : int or array-like, optional\n",
      "            Determines the number and positions of the contour lines / regions.\n",
      "        \n",
      "            If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries to\n",
      "            automatically choose no more than *n+1* \"nice\" contour levels between\n",
      "            *vmin* and *vmax*.\n",
      "        \n",
      "            If array-like, draw contour lines at the specified levels.  The values must\n",
      "            be in increasing order.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.tri.TriContourSet`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        colors : color string or sequence of colors, optional\n",
      "            The colors of the levels, i.e., the contour regions.\n",
      "        \n",
      "            The sequence is cycled for the levels in ascending order. If the sequence\n",
      "            is shorter than the number of levels, it's repeated.\n",
      "        \n",
      "            As a shortcut, single color strings may be used in place of one-element\n",
      "            lists, i.e. ``'red'`` instead of ``['red']`` to color all levels with the\n",
      "            same color. This shortcut does only work for color strings, not for other\n",
      "            ways of specifying colors.\n",
      "        \n",
      "            By default (value *None*), the colormap specified by *cmap* will be used.\n",
      "        \n",
      "        alpha : float, default: 1\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        cmap : str or `.Colormap`, default: :rc:`image.cmap`\n",
      "            A `.Colormap` instance or registered colormap name. The colormap maps the\n",
      "            level values to colors.\n",
      "        \n",
      "            If both *colors* and *cmap* are given, an error is raised.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional\n",
      "            If a colormap is used, the `.Normalize` instance scales the level values to\n",
      "            the canonical colormap range [0, 1] for mapping to colors. If not given,\n",
      "            the default linear scaling is used.\n",
      "        \n",
      "        vmin, vmax : float, optional\n",
      "            If not *None*, either or both of these values will be supplied to\n",
      "            the `.Normalize` instance, overriding the default color scaling\n",
      "            based on *levels*.\n",
      "        \n",
      "        origin : {*None*, 'upper', 'lower', 'image'}, default: None\n",
      "            Determines the orientation and exact position of *Z* by specifying the\n",
      "            position of ``Z[0, 0]``.  This is only relevant, if *X*, *Y* are not given.\n",
      "        \n",
      "            - *None*: ``Z[0, 0]`` is at X=0, Y=0 in the lower left corner.\n",
      "            - 'lower': ``Z[0, 0]`` is at X=0.5, Y=0.5 in the lower left corner.\n",
      "            - 'upper': ``Z[0, 0]`` is at X=N+0.5, Y=0.5 in the upper left corner.\n",
      "            - 'image': Use the value from :rc:`image.origin`.\n",
      "        \n",
      "        extent : (x0, x1, y0, y1), optional\n",
      "            If *origin* is not *None*, then *extent* is interpreted as in `.imshow`: it\n",
      "            gives the outer pixel boundaries. In this case, the position of Z[0, 0] is\n",
      "            the center of the pixel, not a corner. If *origin* is *None*, then\n",
      "            (*x0*, *y0*) is the position of Z[0, 0], and (*x1*, *y1*) is the position\n",
      "            of Z[-1, -1].\n",
      "        \n",
      "            This argument is ignored if *X* and *Y* are specified in the call to\n",
      "            contour.\n",
      "        \n",
      "        locator : ticker.Locator subclass, optional\n",
      "            The locator is used to determine the contour levels if they are not given\n",
      "            explicitly via *levels*.\n",
      "            Defaults to `~.ticker.MaxNLocator`.\n",
      "        \n",
      "        extend : {'neither', 'both', 'min', 'max'}, default: 'neither'\n",
      "            Determines the ``tricontourf``-coloring of values that are outside the\n",
      "            *levels* range.\n",
      "        \n",
      "            If 'neither', values outside the *levels* range are not colored.  If 'min',\n",
      "            'max' or 'both', color the values below, above or below and above the\n",
      "            *levels* range.\n",
      "        \n",
      "            Values below ``min(levels)`` and above ``max(levels)`` are mapped to the\n",
      "            under/over values of the `.Colormap`. Note that most colormaps do not have\n",
      "            dedicated colors for these by default, so that the over and under values\n",
      "            are the edge values of the colormap.  You may want to set these values\n",
      "            explicitly using `.Colormap.set_under` and `.Colormap.set_over`.\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "                An existing `.TriContourSet` does not get notified if properties of its\n",
      "                colormap are changed. Therefore, an explicit call to\n",
      "                `.ContourSet.changed()` is needed after modifying the colormap. The\n",
      "                explicit call can be left out, if a colorbar is assigned to the\n",
      "                `.TriContourSet` because it internally calls `.ContourSet.changed()`.\n",
      "        \n",
      "        xunits, yunits : registered units, optional\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        antialiased : bool, optional\n",
      "            Enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from :rc:`lines.antialiased`.\n",
      "        \n",
      "        hatches : list[str], optional\n",
      "            A list of cross hatch patterns to use on the filled areas.\n",
      "            If None, no hatching will be added to the contour.\n",
      "            Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      "            backends only.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        `.tricontourf` fills intervals that are closed at the top; that is, for\n",
      "        boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < Z <= z2\n",
      "        \n",
      "        except for the lowest interval, which is closed on both sides (i.e. it\n",
      "        includes the lowest value).\n",
      "    \n",
      "    tripcolor(*args, alpha=1.0, norm=None, cmap=None, vmin=None, vmax=None, shading='flat', facecolors=None, **kwargs)\n",
      "        Create a pseudocolor plot of an unstructured triangular grid.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either::\n",
      "        \n",
      "          tripcolor(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a `.Triangulation` object, or\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tripcolor(x, y, ...)\n",
      "          tripcolor(x, y, triangles, ...)\n",
      "          tripcolor(x, y, triangles=triangles, ...)\n",
      "          tripcolor(x, y, mask=mask, ...)\n",
      "          tripcolor(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a Triangulation object will be created.  See `.Triangulation`\n",
      "        for a explanation of these possibilities.\n",
      "        \n",
      "        The next argument must be *C*, the array of color values, either\n",
      "        one per point in the triangulation if color values are defined at\n",
      "        points, or one per triangle in the triangulation if color values\n",
      "        are defined at triangles. If there are the same number of points\n",
      "        and triangles in the triangulation it is assumed that color\n",
      "        values are defined at points; to force the use of color values at\n",
      "        triangles use the kwarg ``facecolors=C`` instead of just ``C``.\n",
      "        \n",
      "        *shading* may be 'flat' (the default) or 'gouraud'. If *shading*\n",
      "        is 'flat' and C values are defined at points, the color values\n",
      "        used for each triangle are from the mean C of the triangle's\n",
      "        three points. If *shading* is 'gouraud' then color values must be\n",
      "        defined at points.\n",
      "        \n",
      "        The remaining kwargs are the same as for `~.Axes.pcolor`.\n",
      "    \n",
      "    triplot(*args, **kwargs)\n",
      "        Draw a unstructured triangular grid as lines and/or markers.\n",
      "        \n",
      "        The triangulation to plot can be specified in one of two ways; either::\n",
      "        \n",
      "          triplot(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a `.Triangulation` object, or\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          triplot(x, y, ...)\n",
      "          triplot(x, y, triangles, ...)\n",
      "          triplot(x, y, triangles=triangles, ...)\n",
      "          triplot(x, y, mask=mask, ...)\n",
      "          triplot(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a Triangulation object will be created.  See `.Triangulation`\n",
      "        for a explanation of these possibilities.\n",
      "        \n",
      "        The remaining args and kwargs are the same as for `~.Axes.plot`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : `~matplotlib.lines.Line2D`\n",
      "            The drawn triangles edges.\n",
      "        markers : `~matplotlib.lines.Line2D`\n",
      "            The drawn marker nodes.\n",
      "    \n",
      "    twinx(ax=None)\n",
      "        Make and return a second axes that shares the *x*-axis.  The new axes will\n",
      "        overlay *ax* (or the current axes if *ax* is *None*), and its ticks will be\n",
      "        on the right.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        :doc:`/gallery/subplots_axes_and_figures/two_scales`\n",
      "    \n",
      "    twiny(ax=None)\n",
      "        Make and return a second axes that shares the *y*-axis.  The new axes will\n",
      "        overlay *ax* (or the current axes if *ax* is *None*), and its ticks will be\n",
      "        on the top.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        :doc:`/gallery/subplots_axes_and_figures/two_scales`\n",
      "    \n",
      "    uninstall_repl_displayhook()\n",
      "        Uninstall the matplotlib display hook.\n",
      "        \n",
      "        .. warning::\n",
      "        \n",
      "           Need IPython >= 2 for this to work.  For IPython < 2 will raise a\n",
      "           ``NotImplementedError``\n",
      "        \n",
      "        .. warning::\n",
      "        \n",
      "           If you are using vanilla python and have installed another\n",
      "           display hook this will reset ``sys.displayhook`` to what ever\n",
      "           function was there when matplotlib installed it's displayhook,\n",
      "           possibly discarding your changes.\n",
      "    \n",
      "    violinplot(dataset, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False, quantiles=None, points=100, bw_method=None, *, data=None)\n",
      "        Make a violin plot.\n",
      "        \n",
      "        Make a violin plot for each column of *dataset* or each vector in\n",
      "        sequence *dataset*.  Each filled area extends to represent the\n",
      "        entire data range, with optional lines at the mean, the median,\n",
      "        the minimum, the maximum, and user-specified quantiles.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        dataset : Array or a sequence of vectors.\n",
      "          The input data.\n",
      "        \n",
      "        positions : array-like, default: [1, 2, ..., n]\n",
      "          The positions of the violins. The ticks and limits are\n",
      "          automatically set to match the positions.\n",
      "        \n",
      "        vert : bool, default: True.\n",
      "          If true, creates a vertical violin plot.\n",
      "          Otherwise, creates a horizontal violin plot.\n",
      "        \n",
      "        widths : array-like, default: 0.5\n",
      "          Either a scalar or a vector that sets the maximal width of\n",
      "          each violin. The default is 0.5, which uses about half of the\n",
      "          available horizontal space.\n",
      "        \n",
      "        showmeans : bool, default: False\n",
      "          If `True`, will toggle rendering of the means.\n",
      "        \n",
      "        showextrema : bool, default: True\n",
      "          If `True`, will toggle rendering of the extrema.\n",
      "        \n",
      "        showmedians : bool, default: False\n",
      "          If `True`, will toggle rendering of the medians.\n",
      "        \n",
      "        quantiles : array-like, default: None\n",
      "          If not None, set a list of floats in interval [0, 1] for each violin,\n",
      "          which stands for the quantiles that will be rendered for that\n",
      "          violin.\n",
      "        \n",
      "        points : int, default: 100\n",
      "          Defines the number of points to evaluate each of the\n",
      "          gaussian kernel density estimations at.\n",
      "        \n",
      "        bw_method : str, scalar or callable, optional\n",
      "          The method used to calculate the estimator bandwidth.  This can be\n",
      "          'scott', 'silverman', a scalar constant or a callable.  If a\n",
      "          scalar, this will be used directly as `kde.factor`.  If a\n",
      "          callable, it should take a `GaussianKDE` instance as its only\n",
      "          parameter and return a scalar. If None (default), 'scott' is used.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        dict\n",
      "          A dictionary mapping each component of the violinplot to a\n",
      "          list of the corresponding collection instances created. The\n",
      "          dictionary has the following keys:\n",
      "        \n",
      "          - ``bodies``: A list of the `~.collections.PolyCollection`\n",
      "            instances containing the filled area of each violin.\n",
      "        \n",
      "          - ``cmeans``: A `~.collections.LineCollection` instance that marks\n",
      "            the mean values of each of the violin's distribution.\n",
      "        \n",
      "          - ``cmins``: A `~.collections.LineCollection` instance that marks\n",
      "            the bottom of each violin's distribution.\n",
      "        \n",
      "          - ``cmaxes``: A `~.collections.LineCollection` instance that marks\n",
      "            the top of each violin's distribution.\n",
      "        \n",
      "          - ``cbars``: A `~.collections.LineCollection` instance that marks\n",
      "            the centers of each violin's distribution.\n",
      "        \n",
      "          - ``cmedians``: A `~.collections.LineCollection` instance that\n",
      "            marks the median values of each of the violin's distribution.\n",
      "        \n",
      "          - ``cquantiles``: A `~.collections.LineCollection` instance created\n",
      "            to identify the quantile values of each of the violin's\n",
      "            distribution.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *dataset*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    viridis()\n",
      "        Set the colormap to 'viridis'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    vlines(x, ymin, ymax, colors=None, linestyles='solid', label='', *, data=None, **kwargs)\n",
      "        Plot vertical lines at each *x* from *ymin* to *ymax*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : float or array-like\n",
      "            x-indexes where to plot the lines.\n",
      "        \n",
      "        ymin, ymax : float or array-like\n",
      "            Respective beginning and end of each line. If scalars are\n",
      "            provided, all lines will have same length.\n",
      "        \n",
      "        colors : list of colors, default: :rc:`lines.color`\n",
      "        \n",
      "        linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional\n",
      "        \n",
      "        label : str, default: ''\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.collections.LineCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.collections.LineCollection` properties.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        hlines : horizontal lines\n",
      "        axvline : vertical line across the Axes\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *ymin*, *ymax*, *colors*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    waitforbuttonpress(timeout=-1)\n",
      "        Blocking call to interact with the figure.\n",
      "        \n",
      "        Wait for user input and return True if a key was pressed, False if a\n",
      "        mouse button was pressed and None if no input was given within\n",
      "        *timeout* seconds.  Negative values deactivate *timeout*.\n",
      "    \n",
      "    winter()\n",
      "        Set the colormap to 'winter'.\n",
      "        \n",
      "        This changes the default colormap as well as the colormap of the current\n",
      "        image if there is one. See ``help(colormaps)`` for more information.\n",
      "    \n",
      "    xcorr(x, y, normed=True, detrend=<function detrend_none at 0x0000018044793AF0>, usevlines=True, maxlags=10, *, data=None, **kwargs)\n",
      "        Plot the cross correlation between *x* and *y*.\n",
      "        \n",
      "        The correlation with lag k is defined as\n",
      "        :math:`\\sum_n x[n+k] \\cdot y^*[n]`, where :math:`y^*` is the complex\n",
      "        conjugate of :math:`y`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array-like of length n\n",
      "        \n",
      "        detrend : callable, default: `.mlab.detrend_none` (no detrending)\n",
      "            A detrending function applied to *x* and *y*.  It must have the\n",
      "            signature ::\n",
      "        \n",
      "                detrend(x: np.ndarray) -> np.ndarray\n",
      "        \n",
      "        normed : bool, default: True\n",
      "            If ``True``, input vectors are normalised to unit length.\n",
      "        \n",
      "        usevlines : bool, default: True\n",
      "            Determines the plot style.\n",
      "        \n",
      "            If ``True``, vertical lines are plotted from 0 to the xcorr value\n",
      "            using `.Axes.vlines`. Additionally, a horizontal line is plotted\n",
      "            at y=0 using `.Axes.axhline`.\n",
      "        \n",
      "            If ``False``, markers are plotted at the xcorr values using\n",
      "            `.Axes.plot`.\n",
      "        \n",
      "        maxlags : int, default: 10\n",
      "            Number of lags to show. If None, will return all ``2 * len(x) - 1``\n",
      "            lags.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lags : array (length ``2*maxlags+1``)\n",
      "            The lag vector.\n",
      "        c : array  (length ``2*maxlags+1``)\n",
      "            The auto correlation vector.\n",
      "        line : `.LineCollection` or `.Line2D`\n",
      "            `.Artist` added to the Axes of the correlation:\n",
      "        \n",
      "            - `.LineCollection` if *usevlines* is True.\n",
      "            - `.Line2D` if *usevlines* is False.\n",
      "        b : `.Line2D` or None\n",
      "            Horizontal line at 0 if *usevlines* is True\n",
      "            None *usevlines* is False.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        linestyle : `.Line2D` property, optional\n",
      "            The linestyle for plotting the data points.\n",
      "            Only used if *usevlines* is ``False``.\n",
      "        \n",
      "        marker : str, default: 'o'\n",
      "            The marker for plotting the data points.\n",
      "            Only used if *usevlines* is ``False``.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional parameters are passed to `.Axes.vlines` and\n",
      "            `.Axes.axhline` if *usevlines* is ``True``; otherwise they are\n",
      "            passed to `.Axes.plot`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cross correlation is performed with `numpy.correlate` with\n",
      "        ``mode = \"full\"``.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take\n",
      "            a *data* keyword argument. If such a *data* argument is given,\n",
      "            the following arguments can also be string ``s``, which is\n",
      "            interpreted as ``data[s]`` (unless this raises an exception):\n",
      "            *x*, *y*.\n",
      "        \n",
      "            Objects passed as **data** must support item access (``data[s]``) and\n",
      "            membership test (``s in data``).\n",
      "    \n",
      "    xkcd(scale=1, length=100, randomness=2)\n",
      "        Turn on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.  This will\n",
      "        only have effect on things drawn after this function is called.\n",
      "        \n",
      "        For best results, the \"Humor Sans\" font should be installed: it is\n",
      "        not included with Matplotlib.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        scale : float, optional\n",
      "            The amplitude of the wiggle perpendicular to the source line.\n",
      "        length : float, optional\n",
      "            The length of the wiggle along the line.\n",
      "        randomness : float, optional\n",
      "            The scale factor by which the length is shrunken or expanded.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This function works by a number of rcParams, so it will probably\n",
      "        override others you have set before.\n",
      "        \n",
      "        If you want the effects of this function to be temporary, it can\n",
      "        be used as a context manager, for example::\n",
      "        \n",
      "            with plt.xkcd():\n",
      "                # This figure will be in XKCD-style\n",
      "                fig1 = plt.figure()\n",
      "                # ...\n",
      "        \n",
      "            # This figure will be in regular style\n",
      "            fig2 = plt.figure()\n",
      "    \n",
      "    xlabel(xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)\n",
      "        Set the label for the x-axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xlabel : str\n",
      "            The label text.\n",
      "        \n",
      "        labelpad : float, default: :rc:`axes.labelpad`\n",
      "            Spacing in points from the axes bounding box including ticks\n",
      "            and tick labels.  If None, the previous value is left as is.\n",
      "        \n",
      "        loc : {'left', 'center', 'right'}, default: :rc:`xaxis.labellocation`\n",
      "            The label position. This is a high-level alternative for passing\n",
      "            parameters *x* and *horizontalalignment*.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `.Text` properties\n",
      "            `.Text` properties control the appearance of the label.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        text : Documents the properties supported by `.Text`.\n",
      "    \n",
      "    xlim(*args, **kwargs)\n",
      "        Get or set the x limits of the current axes.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            left, right = xlim()  # return the current xlim\n",
      "            xlim((left, right))   # set the xlim to left, right\n",
      "            xlim(left, right)     # set the xlim to left, right\n",
      "        \n",
      "        If you do not specify args, you can pass *left* or *right* as kwargs,\n",
      "        i.e.::\n",
      "        \n",
      "            xlim(right=3)  # adjust the right leaving left unchanged\n",
      "            xlim(left=1)  # adjust the left leaving right unchanged\n",
      "        \n",
      "        Setting limits turns autoscaling off for the x-axis.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        left, right\n",
      "            A tuple of the new x-axis limits.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Calling this function with no arguments (e.g. ``xlim()``) is the pyplot\n",
      "        equivalent of calling `~.Axes.get_xlim` on the current axes.\n",
      "        Calling this function with arguments is the pyplot equivalent of calling\n",
      "        `~.Axes.set_xlim` on the current axes. All arguments are passed though.\n",
      "    \n",
      "    xscale(value, **kwargs)\n",
      "        Set the x-axis scale.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        value : {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            The axis scale type to apply.\n",
      "        \n",
      "        **kwargs\n",
      "            Different keyword arguments are accepted, depending on the scale.\n",
      "            See the respective class keyword arguments:\n",
      "        \n",
      "            - `matplotlib.scale.LinearScale`\n",
      "            - `matplotlib.scale.LogScale`\n",
      "            - `matplotlib.scale.SymmetricalLogScale`\n",
      "            - `matplotlib.scale.LogitScale`\n",
      "            - `matplotlib.scale.FuncScale`\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        By default, Matplotlib supports the above mentioned scales.\n",
      "        Additionally, custom scales may be registered using\n",
      "        `matplotlib.scale.register_scale`. These scales can then also\n",
      "        be used here.\n",
      "    \n",
      "    xticks(ticks=None, labels=None, **kwargs)\n",
      "        Get or set the current tick locations and labels of the x-axis.\n",
      "        \n",
      "        Pass no arguments to return the current values without modifying them.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ticks : array-like, optional\n",
      "            The list of xtick locations.  Passing an empty list removes all xticks.\n",
      "        labels : array-like, optional\n",
      "            The labels to place at the given *ticks* locations.  This argument can\n",
      "            only be passed if *ticks* is passed as well.\n",
      "        **kwargs\n",
      "            `.Text` properties can be used to control the appearance of the labels.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        locs\n",
      "            The list of xtick locations.\n",
      "        labels\n",
      "            The list of xlabel `.Text` objects.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Calling this function with no arguments (e.g. ``xticks()``) is the pyplot\n",
      "        equivalent of calling `~.Axes.get_xticks` and `~.Axes.get_xticklabels` on\n",
      "        the current axes.\n",
      "        Calling this function with arguments is the pyplot equivalent of calling\n",
      "        `~.Axes.set_xticks` and `~.Axes.set_xticklabels` on the current axes.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> locs, labels = xticks()  # Get the current locations and labels.\n",
      "        >>> xticks(np.arange(0, 1, step=0.2))  # Set label locations.\n",
      "        >>> xticks(np.arange(3), ['Tom', 'Dick', 'Sue'])  # Set text labels.\n",
      "        >>> xticks([0, 1, 2], ['January', 'February', 'March'],\n",
      "        ...        rotation=20)  # Set text labels and properties.\n",
      "        >>> xticks([])  # Disable xticks.\n",
      "    \n",
      "    ylabel(ylabel, fontdict=None, labelpad=None, *, loc=None, **kwargs)\n",
      "        Set the label for the y-axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ylabel : str\n",
      "            The label text.\n",
      "        \n",
      "        labelpad : float, default: :rc:`axes.labelpad`\n",
      "            Spacing in points from the axes bounding box including ticks\n",
      "            and tick labels.  If None, the previous value is left as is.\n",
      "        \n",
      "        loc : {'bottom', 'center', 'top'}, default: :rc:`yaxis.labellocation`\n",
      "            The label position. This is a high-level alternative for passing\n",
      "            parameters *y* and *horizontalalignment*.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `.Text` properties\n",
      "            `.Text` properties control the appearance of the label.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        text : Documents the properties supported by `.Text`.\n",
      "    \n",
      "    ylim(*args, **kwargs)\n",
      "        Get or set the y-limits of the current axes.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            bottom, top = ylim()  # return the current ylim\n",
      "            ylim((bottom, top))   # set the ylim to bottom, top\n",
      "            ylim(bottom, top)     # set the ylim to bottom, top\n",
      "        \n",
      "        If you do not specify args, you can alternatively pass *bottom* or\n",
      "        *top* as kwargs, i.e.::\n",
      "        \n",
      "            ylim(top=3)  # adjust the top leaving bottom unchanged\n",
      "            ylim(bottom=1)  # adjust the bottom leaving top unchanged\n",
      "        \n",
      "        Setting limits turns autoscaling off for the y-axis.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        bottom, top\n",
      "            A tuple of the new y-axis limits.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Calling this function with no arguments (e.g. ``ylim()``) is the pyplot\n",
      "        equivalent of calling `~.Axes.get_ylim` on the current axes.\n",
      "        Calling this function with arguments is the pyplot equivalent of calling\n",
      "        `~.Axes.set_ylim` on the current axes. All arguments are passed though.\n",
      "    \n",
      "    yscale(value, **kwargs)\n",
      "        Set the y-axis scale.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        value : {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n",
      "            The axis scale type to apply.\n",
      "        \n",
      "        **kwargs\n",
      "            Different keyword arguments are accepted, depending on the scale.\n",
      "            See the respective class keyword arguments:\n",
      "        \n",
      "            - `matplotlib.scale.LinearScale`\n",
      "            - `matplotlib.scale.LogScale`\n",
      "            - `matplotlib.scale.SymmetricalLogScale`\n",
      "            - `matplotlib.scale.LogitScale`\n",
      "            - `matplotlib.scale.FuncScale`\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        By default, Matplotlib supports the above mentioned scales.\n",
      "        Additionally, custom scales may be registered using\n",
      "        `matplotlib.scale.register_scale`. These scales can then also\n",
      "        be used here.\n",
      "    \n",
      "    yticks(ticks=None, labels=None, **kwargs)\n",
      "        Get or set the current tick locations and labels of the y-axis.\n",
      "        \n",
      "        Pass no arguments to return the current values without modifying them.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ticks : array-like, optional\n",
      "            The list of ytick locations.  Passing an empty list removes all yticks.\n",
      "        labels : array-like, optional\n",
      "            The labels to place at the given *ticks* locations.  This argument can\n",
      "            only be passed if *ticks* is passed as well.\n",
      "        **kwargs\n",
      "            `.Text` properties can be used to control the appearance of the labels.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        locs\n",
      "            The list of ytick locations.\n",
      "        labels\n",
      "            The list of ylabel `.Text` objects.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Calling this function with no arguments (e.g. ``yticks()``) is the pyplot\n",
      "        equivalent of calling `~.Axes.get_yticks` and `~.Axes.get_yticklabels` on\n",
      "        the current axes.\n",
      "        Calling this function with arguments is the pyplot equivalent of calling\n",
      "        `~.Axes.set_yticks` and `~.Axes.set_yticklabels` on the current axes.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> locs, labels = yticks()  # Get the current locations and labels.\n",
      "        >>> yticks(np.arange(0, 1, step=0.2))  # Set label locations.\n",
      "        >>> yticks(np.arange(3), ['Tom', 'Dick', 'Sue'])  # Set text labels.\n",
      "        >>> yticks([0, 1, 2], ['January', 'February', 'March'],\n",
      "        ...        rotation=45)  # Set text labels and properties.\n",
      "        >>> yticks([])  # Disable yticks.\n",
      "\n",
      "DATA\n",
      "    rcParams = RcParams({'_internal.classic_mode': False,\n",
      "         ...nor.widt...\n",
      "    rcParamsDefault = RcParams({'_internal.classic_mode': False,\n",
      "         ...n...\n",
      "    rcParamsOrig = RcParams({'_internal.classic_mode': False,\n",
      "         ...nor....\n",
      "\n",
      "FILE\n",
      "    c:\\users\\junaid\\anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#split data\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test= train_test_split(X ,y, test_size=1/5, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of train input data:  (1437, 64)\n",
      "shape of test input data:  (360, 64)\n",
      "shape of train output data:  (1437,)\n",
      "shape of test output data:  (360,)\n"
     ]
    }
   ],
   "source": [
    "print(\"shape of train input data: \",X_train.shape)\n",
    "print(\"shape of test input data: \",X_test.shape)\n",
    "print(\"shape of train output data: \",y_train.shape)\n",
    "print(\"shape of test output data: \",y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Junaid\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:763: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LogisticRegression()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "model= LogisticRegression().fit(X_train,y_train)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 8, 2, 6, 6, 7, 1, 9, 8, 5, 2, 8, 6, 6, 6, 6, 1, 0, 5, 8, 8, 7,\n",
       "       8, 4, 7, 5, 4, 9, 2, 9, 4, 7, 6, 8, 9, 4, 3, 1, 0, 1, 8, 6, 7, 7,\n",
       "       1, 0, 7, 6, 2, 1, 9, 6, 7, 9, 0, 0, 9, 1, 6, 3, 0, 2, 3, 4, 1, 9,\n",
       "       2, 6, 9, 1, 8, 3, 5, 1, 2, 8, 2, 2, 9, 7, 2, 3, 6, 0, 9, 3, 7, 5,\n",
       "       1, 2, 9, 9, 3, 1, 4, 7, 4, 8, 5, 8, 5, 5, 2, 5, 9, 0, 7, 1, 4, 7,\n",
       "       3, 4, 8, 9, 7, 9, 8, 2, 1, 5, 2, 5, 8, 4, 1, 7, 0, 6, 1, 5, 5, 9,\n",
       "       9, 5, 9, 9, 5, 7, 5, 6, 2, 8, 6, 9, 6, 1, 5, 1, 5, 9, 9, 1, 5, 3,\n",
       "       6, 1, 8, 9, 8, 7, 6, 7, 6, 5, 6, 0, 8, 8, 9, 8, 6, 1, 0, 4, 1, 6,\n",
       "       3, 8, 6, 7, 4, 9, 6, 3, 0, 3, 3, 3, 0, 7, 7, 5, 7, 8, 0, 7, 1, 9,\n",
       "       6, 4, 5, 0, 1, 4, 6, 4, 3, 3, 0, 9, 5, 9, 2, 1, 4, 2, 1, 6, 8, 9,\n",
       "       2, 4, 9, 3, 7, 6, 2, 3, 3, 1, 6, 9, 3, 6, 3, 3, 2, 0, 7, 6, 1, 1,\n",
       "       9, 7, 2, 7, 8, 5, 5, 7, 5, 2, 3, 7, 2, 7, 5, 5, 7, 0, 9, 1, 6, 5,\n",
       "       9, 7, 4, 3, 8, 0, 3, 6, 4, 6, 3, 2, 6, 8, 8, 8, 4, 6, 7, 5, 2, 4,\n",
       "       5, 3, 2, 4, 6, 9, 4, 5, 4, 3, 4, 6, 2, 9, 0, 1, 7, 2, 0, 9, 6, 0,\n",
       "       4, 2, 0, 7, 9, 8, 5, 7, 8, 2, 8, 4, 3, 7, 2, 6, 9, 1, 5, 1, 0, 8,\n",
       "       2, 8, 9, 5, 6, 2, 2, 7, 2, 1, 5, 1, 6, 4, 5, 0, 9, 4, 1, 1, 7, 0,\n",
       "       8, 9, 0, 5, 4, 3, 8, 8])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(X_test[0:10])\n",
    "# or\n",
    "predictions = model.predict(X_test)\n",
    "predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the accuracy score is:  0.9666666666666667\n"
     ]
    }
   ],
   "source": [
    "#accuracy score\n",
    "score = model.score(X_test,y_test)\n",
    "print(\"the accuracy score is: \",score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[27,  0,  0,  0,  0,  0,  0,  0,  0,  0],\n",
       "       [ 0, 34,  0,  0,  0,  0,  0,  0,  1,  0],\n",
       "       [ 0,  0, 35,  1,  0,  0,  0,  0,  0,  0],\n",
       "       [ 0,  0,  0, 29,  0,  0,  0,  0,  0,  0],\n",
       "       [ 0,  0,  0,  0, 29,  0,  0,  1,  0,  0],\n",
       "       [ 0,  0,  0,  0,  0, 37,  0,  0,  0,  3],\n",
       "       [ 0,  1,  0,  0,  0,  0, 43,  0,  0,  0],\n",
       "       [ 0,  0,  0,  0,  1,  0,  0, 38,  0,  0],\n",
       "       [ 0,  2,  1,  0,  0,  0,  0,  0, 36,  0],\n",
       "       [ 0,  0,  0,  0,  0,  1,  0,  0,  0, 40]], dtype=int64)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# confusion metrix\n",
    "from sklearn import metrics\n",
    "cm = metrics.confusion_matrix(y_test, predictions)\n",
    "cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x648 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw in table format\n",
    "\n",
    "import seaborn as sns\n",
    "plt.figure(figsize=(9,9))\n",
    "sns.heatmap(cm, annot=True, fmt= \".3f\", linewidths=.5, square = True, cmap = 'Spectral');\n",
    "plt.ylabel('Actual Output');\n",
    "plt.xlabel('Predicted Output');\n",
    "all_sample_title = 'Accuracy Score: {0}'.format(score);\n",
    "plt.title(all_sample_title, size = 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[27  0  0  0  0  0  0  0  0  0]\n",
      " [ 0 34  0  0  0  0  0  0  1  0]\n",
      " [ 0  0 35  1  0  0  0  0  0  0]\n",
      " [ 0  0  0 29  0  0  0  0  0  0]\n",
      " [ 0  0  0  0 29  0  0  1  0  0]\n",
      " [ 0  0  0  0  0 37  0  0  0  3]\n",
      " [ 0  1  0  0  0  0 43  0  0  0]\n",
      " [ 0  0  0  0  1  0  0 38  0  0]\n",
      " [ 0  2  1  0  0  0  0  0 36  0]\n",
      " [ 0  0  0  0  0  1  0  0  0 40]]\n"
     ]
    }
   ],
   "source": [
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Getting miss classified labels\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "index = 0\n",
    "misclassifiedIndexes = []\n",
    "for label, predict in zip(y_test, predictions):\n",
    "    if label != predict:\n",
    "     misclassifiedIndexes.append(index)\n",
    "     index +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x648 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting missclassified labels with known\n",
    "plt.figure(figsize=(9,9))\n",
    "for plotIndex , badIndex in enumerate( misclassifiedIndexes[0:5]):\n",
    "    plt.subplot(1,5, plotIndex + 1)\n",
    "    plt.imshow(np.reshape(X_test[badIndex],(8,8)),cmap=plt.cm.gray)\n",
    "    plt.title(\"predicted:{},actual:{}\".format(predictions[badIndex],y_test[badIndex]),fontsize= 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "db9da9d256f457015986a8acd5c7819a5914eb9a575ecff51b37f60a7d912a81"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}