ionogramparser.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "print('starting')\n",
    "\n",
    "with open('data/NHPC_Profiles-20181012000000-28192') as fi:\n",
    "    hli = 0    # header line index\n",
    "    rep = []\n",
    "    loc_name = ''\n",
    "    loc_id = ''\n",
    "    date = ''\n",
    "    time = ''\n",
    "    \n",
    "    for line in fi:\n",
    "        if hli == 0:\n",
    "            [loc_name, loc_id, date, time] = line.split()\n",
    "            loc_id = loc_id[1:-2]\n",
    "            hli = 1\n",
    "            continue\n",
    "            \n",
    "        elif hli < 4:\n",
    "            hli += 1\n",
    "            continue\n",
    "        \n",
    "        elif line == '===\\n':\n",
    "            ofn = 'data/processed/' + loc_id + '_' + date + '_' + time + '.csv'\n",
    "            if len(rep) > 0 and rep[0] != '\\n':\n",
    "                with open(ofn, 'w') as fo:\n",
    "                    fo.write('Height,Frequency,Density\\n')\n",
    "                    for ol in rep:\n",
    "                        op = ''\n",
    "                        for os in ol.split():\n",
    "                            op += os + ','\n",
    "                        fo.write(op[0:-1] + '\\n')\n",
    "            hli = 0\n",
    "            rep.clear()\n",
    "        else:\n",
    "            rep.append(line)\n",
    "            \n",
    "print('end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f219da73710>]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.read_csv('data/processed/mo155_2018-10-12_00:01:00.csv')\n",
    "\n",
    "plt.plot(df['Density'], df['Height'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "world = np.flip(np.tile(np.repeat(df['Density'], 10), (1000,1)).T, 0)\n",
    "\n",
    "# plt.imshow(world, interpolation='nearest', cmap=cm.winter)\n",
    "plt.imshow(world, interpolation='nearest')\n",
    "plt.plot(np.linspace(0, 1000, 1000),np.linspace(0, 1000, 1000), 'r')\n",
    "\n",
    "pos = np.array([400, 0])\n",
    "vel = np.array([10, 10])\n",
    "\n",
    "path = []\n",
    "\n",
    "while True:\n",
    "    rho = world[pos[0]][pos[1]]\n",
    "    theta = np.acos(np.sqrt((rho + 10) / rho)\n",
    "    pos_new = pos + vel\n",
    "    \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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 programmatic\n",
      "    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, hold=None, data=None, **kwargs)\n",
      "        Plot the autocorrelation of *x*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        x : sequence of scalar\n",
      "        \n",
      "        hold : bool, optional, *deprecated*, default: True\n",
      "        \n",
      "        detrend : callable, optional, default: `mlab.detrend_none`\n",
      "            *x* is detrended by the *detrend* callable. Default is no\n",
      "            normalization.\n",
      "        \n",
      "        normed : bool, optional, default: True\n",
      "            If ``True``, input vectors are normalised to unit length.\n",
      "        \n",
      "        usevlines : bool, optional, default: True\n",
      "            If ``True``, `Axes.vlines` is used to plot the vertical lines from\n",
      "            the origin to the acorr. Otherwise, `Axes.plot` is used.\n",
      "        \n",
      "        maxlags : integer, optional, 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 (lenth ``2*maxlags+1``)\n",
      "            lag vector.\n",
      "        c : array  (length ``2*maxlags+1``)\n",
      "            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 : `~matplotlib.lines.Line2D` prop, optional, default: None\n",
      "            Only used if usevlines is ``False``.\n",
      "        \n",
      "        marker : string, optional, default: 'o'\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cross correlation is performed with :func:`numpy.correlate` with\n",
      "        ``mode = 2``.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    angle_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, hold=None, data=None, **kwargs)\n",
      "        Plot the angle spectrum.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          angle_spectrum(x, Fs=2, Fc=0,  window=mlab.window_hanning,\n",
      "                         pad_to=None, sides='default', **kwargs)\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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  While not increasing the actual resolution of\n",
      "            the spectrum (the minimum distance between resolvable peaks),\n",
      "            this can give more points in the plot, allowing for more\n",
      "            detail. This corresponds to the *n* parameter in the call to fft().\n",
      "            The default is None, which sets *pad_to* equal to the length of the\n",
      "            input signal (i.e. no padding).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            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 : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`magnitude_spectrum`\n",
      "            :func:`angle_spectrum` plots the magnitudes of the corresponding\n",
      "            frequencies.\n",
      "        \n",
      "        :func:`phase_spectrum`\n",
      "            :func:`phase_spectrum` plots the unwrapped version of this\n",
      "            function.\n",
      "        \n",
      "        :func:`specgram`\n",
      "            :func:`specgram` can plot the angle spectrum of segments within the\n",
      "            signal in a colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    annotate(*args, **kwargs)\n",
      "        Annotate the point ``xy`` with text ``s``.\n",
      "        \n",
      "        Additional kwargs are passed to `~matplotlib.text.Text`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        s : str\n",
      "            The text of the annotation\n",
      "        \n",
      "        xy : iterable\n",
      "            Length 2 sequence specifying the *(x,y)* point to annotate\n",
      "        \n",
      "        xytext : iterable, optional\n",
      "            Length 2 sequence specifying the *(x,y)* to place the text\n",
      "            at.  If None, defaults to ``xy``.\n",
      "        \n",
      "        xycoords : str, Artist, Transform, callable or tuple, optional\n",
      "        \n",
      "            The coordinate system that ``xy`` is given in.\n",
      "        \n",
      "            For a `str` the allowed values are:\n",
      "        \n",
      "            =================   ===============================================\n",
      "            Property            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",
      "            '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 being\n",
      "                                annotated (default)\n",
      "            'polar'             *(theta,r)* if not native 'data' coordinates\n",
      "            =================   ===============================================\n",
      "        \n",
      "            If a `~matplotlib.artist.Artist` object is passed in the units are\n",
      "            fraction if it's bounding box.\n",
      "        \n",
      "            If a `~matplotlib.transforms.Transform` object is passed\n",
      "            in use that to transform ``xy`` to screen coordinates\n",
      "        \n",
      "            If a callable it must take a\n",
      "            `~matplotlib.backend_bases.RendererBase` object as input\n",
      "            and return a `~matplotlib.transforms.Transform` or\n",
      "            `~matplotlib.transforms.Bbox` object\n",
      "        \n",
      "            If a `tuple` must be length 2 tuple of str, `Artist`,\n",
      "            `Transform` or callable objects.  The first transform is\n",
      "            used for the *x* coordinate and the second for *y*.\n",
      "        \n",
      "            See :ref:`plotting-guide-annotation` for more details.\n",
      "        \n",
      "            Defaults to ``'data'``\n",
      "        \n",
      "        textcoords : str, `Artist`, `Transform`, callable or tuple, optional\n",
      "            The coordinate system that ``xytext`` is given, which\n",
      "            may be different than the coordinate system used for\n",
      "            ``xy``.\n",
      "        \n",
      "            All ``xycoords`` values are valid as well as the following\n",
      "            strings:\n",
      "        \n",
      "            =================   =========================================\n",
      "            Property            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",
      "            defaults to the input of ``xycoords``\n",
      "        \n",
      "        arrowprops : dict, optional\n",
      "            If not None, properties used to draw a\n",
      "            `~matplotlib.patches.FancyArrowPatch` arrow between ``xy`` and\n",
      "            ``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 the `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\n",
      "        \n",
      "        annotation_clip : bool, optional\n",
      "            Controls the visibility of the annotation when it goes\n",
      "            outside the axes area.\n",
      "        \n",
      "            If `True`, the annotation will only be drawn when the\n",
      "            ``xy`` is inside the axes. If `False`, the annotation will\n",
      "            always be drawn regardless of its position.\n",
      "        \n",
      "            The default is `None`, which behave as `True` only if\n",
      "            *xycoords* is \"data\".\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Annotation\n",
      "    \n",
      "    arrow(x, y, dx, dy, hold=None, **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/y-coordinate of the arrow base.\n",
      "        dx, dy : float\n",
      "            The length of the arrow along x/y-direction.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        arrow : `.FancyArrow`\n",
      "            The created `.FancyArrow` object.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Optional kwargs (inherited from `.FancyArrow` patch) control the\n",
      "            arrow construction and properties:\n",
      "        \n",
      "        Constructor arguments\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",
      "        Other valid kwargs (inherited from :class:`Patch`) are:\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: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: bool or None \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `.Figure` instance \n",
      "          fill: bool \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float \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, optional\n",
      "            True (default) turns autoscaling on, False turns it off.\n",
      "            None leaves the autoscaling state unchanged.\n",
      "        \n",
      "        axis : ['both' | 'x' | 'y'], optional\n",
      "            which axis to operate on; default is 'both'\n",
      "        \n",
      "        tight: bool or None, optional\n",
      "            If True, set view limits to data limits;\n",
      "            if False, let the locator and margins expand the view limits;\n",
      "            if None, use tight scaling if the only artist is an image,\n",
      "            otherwise treat *tight* as False.\n",
      "            The *tight* setting is retained for future autoscaling\n",
      "            until it is explicitly changed.\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",
      "        Parameters\n",
      "        ----------\n",
      "        arg : None or 4-tuple or Axes\n",
      "            The exact behavior of this function depends on the type:\n",
      "        \n",
      "            - *None*: A new full window axes is added using\n",
      "              ``subplot(111, **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",
      "            - `.Axes`: This is equivalent to `.pyplot.sca`. It sets the current\n",
      "              axes to *arg*. Note: This implicitly changes the current figure to\n",
      "              the parent of *arg*.\n",
      "        \n",
      "              .. note:: The use of an Axes as an argument is deprecated and will be\n",
      "                        removed in v3.0. Please use `.pyplot.sca` instead.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            For allowed keyword arguments see `.pyplot.subplot` and\n",
      "            `.Figure.add_axes` respectively. Some common keyword arguments are\n",
      "            listed below:\n",
      "        \n",
      "            ========= =========== =================================================\n",
      "            kwarg     Accepts     Description\n",
      "            ========= =========== =================================================\n",
      "            facecolor color       the axes background color\n",
      "            frameon   bool        whether to display the frame\n",
      "            sharex    otherax     share x-axis with *otherax*\n",
      "            sharey    otherax     share y-axis with *otherax*\n",
      "            polar     bool        whether to use polar axes\n",
      "            aspect    [str | num] ['equal', 'auto'] or a number.  If a number, the\n",
      "                                  ratio of y-unit/x-unit in screen-space.  See also\n",
      "                                  `~.Axes.set_aspect`.\n",
      "            ========= =========== =================================================\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        axes : Axes\n",
      "            The created or activated axes.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Creating a new full window axes::\n",
      "        \n",
      "            >>> plt.axes()\n",
      "        \n",
      "        Creating a new axes with specified dimensions and some kwargs::\n",
      "        \n",
      "            >>> plt.axes((left, bottom, width, height), facecolor='w')\n",
      "    \n",
      "    axhline(y=0, xmin=0, xmax=1, hold=None, **kwargs)\n",
      "        Add a horizontal line across the axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : scalar, optional, default: 0\n",
      "            y position in data coordinates of the horizontal line.\n",
      "        \n",
      "        xmin : scalar, optional, 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 : scalar, optional, 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",
      "        :class:`~matplotlib.lines.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,\n",
      "            with the exception of 'transform':\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \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",
      "        \n",
      "        Examples\n",
      "        --------\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, hold=None, **kwargs)\n",
      "        Add a horizontal span (rectangle) across the axis.\n",
      "        \n",
      "        Draw a horizontal span (rectangle) from *ymin* to *ymax*.\n",
      "        With the default values of *xmin* = 0 and *xmax* = 1, this\n",
      "        always spans the xrange, regardless of the xlim settings, even\n",
      "        if you change them, e.g., with the :meth:`set_xlim` command.\n",
      "        That is, the horizontal extent is in axes coords: 0=left,\n",
      "        0.5=middle, 1.0=right but the *y* location is in data\n",
      "        coordinates.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ymin : float\n",
      "               Lower limit of the horizontal span in data units.\n",
      "        ymax : float\n",
      "               Upper limit of the horizontal span in data units.\n",
      "        xmin : float, optional, default: 0\n",
      "               Lower limit of the vertical span in axes (relative\n",
      "               0-1) units.\n",
      "        xmax : float, optional, default: 1\n",
      "               Upper limit of the vertical span in axes (relative\n",
      "               0-1) units.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Polygon : `~matplotlib.patches.Polygon`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Polygon` properties.\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: bool or None \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `.Figure` instance \n",
      "          fill: bool \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        axvspan : Add a vertical span across the axes.\n",
      "    \n",
      "    axis(*v, **kwargs)\n",
      "        Convenience method to get or set axis properties.\n",
      "        \n",
      "        Calling with no arguments::\n",
      "        \n",
      "          >>> axis()\n",
      "        \n",
      "        returns the current axes limits ``[xmin, xmax, ymin, ymax]``.::\n",
      "        \n",
      "          >>> axis(v)\n",
      "        \n",
      "        sets the min and max of the x and y axes, with\n",
      "        ``v = [xmin, xmax, ymin, ymax]``.::\n",
      "        \n",
      "          >>> axis('off')\n",
      "        \n",
      "        turns off the axis lines and labels.::\n",
      "        \n",
      "          >>> axis('equal')\n",
      "        \n",
      "        changes limits of *x* or *y* axis so that equal increments of *x*\n",
      "        and *y* have the same length; a circle is circular.::\n",
      "        \n",
      "          >>> axis('scaled')\n",
      "        \n",
      "        achieves the same result by changing the dimensions of the plot box instead\n",
      "        of the axis data limits.::\n",
      "        \n",
      "          >>> axis('tight')\n",
      "        \n",
      "        changes *x* and *y* axis limits such that all data is shown. If\n",
      "        all data is already shown, it will move it to the center of the\n",
      "        figure without modifying (*xmax* - *xmin*) or (*ymax* -\n",
      "        *ymin*). Note this is slightly different than in MATLAB.::\n",
      "        \n",
      "          >>> axis('image')\n",
      "        \n",
      "        is 'scaled' with the axis limits equal to the data limits.::\n",
      "        \n",
      "          >>> axis('auto')\n",
      "        \n",
      "        and::\n",
      "        \n",
      "          >>> axis('normal')\n",
      "        \n",
      "        are deprecated. They restore default behavior; axis limits are automatically\n",
      "        scaled to make the data fit comfortably within the plot box.\n",
      "        \n",
      "        if ``len(*v)==0``, you can pass in *xmin*, *xmax*, *ymin*, *ymax*\n",
      "        as kwargs selectively to alter just those limits without changing\n",
      "        the others.\n",
      "        \n",
      "          >>> axis('square')\n",
      "        \n",
      "        changes the limit ranges (*xmax*-*xmin*) and (*ymax*-*ymin*) of\n",
      "        the *x* and *y* axes to be the same, and have the same scaling,\n",
      "        resulting in a square plot.\n",
      "        \n",
      "        The xmin, xmax, ymin, ymax tuple is returned\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`xlim`, :func:`ylim`\n",
      "               For setting the x- and y-limits individually.\n",
      "    \n",
      "    axvline(x=0, ymin=0, ymax=1, hold=None, **kwargs)\n",
      "        Add a vertical line across the axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : scalar, optional, default: 0\n",
      "            x position in data coordinates of the vertical line.\n",
      "        \n",
      "        ymin : scalar, optional, 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 : scalar, optional, 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",
      "        :class:`~matplotlib.lines.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,\n",
      "            with the exception of 'transform':\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \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",
      "        See also\n",
      "        --------\n",
      "        vlines : Add vertical lines in data coordinates.\n",
      "        axvspan : Add a vertical span (rectangle) across the axis.\n",
      "    \n",
      "    axvspan(xmin, xmax, ymin=0, ymax=1, hold=None, **kwargs)\n",
      "        Add a vertical span (rectangle) across the axes.\n",
      "        \n",
      "        Draw a vertical span (rectangle) from `xmin` to `xmax`.  With\n",
      "        the default values of `ymin` = 0 and `ymax` = 1. This always\n",
      "        spans the yrange, regardless of the ylim settings, even if you\n",
      "        change them, e.g., with the :meth:`set_ylim` command.  That is,\n",
      "        the vertical extent is in axes coords: 0=bottom, 0.5=middle,\n",
      "        1.0=top but the y location is in data coordinates.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xmin : scalar\n",
      "            Number indicating the first X-axis coordinate of the vertical\n",
      "            span rectangle in data units.\n",
      "        xmax : scalar\n",
      "            Number indicating the second X-axis coordinate of the vertical\n",
      "            span rectangle in data units.\n",
      "        ymin : scalar, optional\n",
      "            Number indicating the first Y-axis coordinate of the vertical\n",
      "            span rectangle in relative Y-axis units (0-1). Default to 0.\n",
      "        ymax : scalar, optional\n",
      "            Number indicating the second Y-axis coordinate of the vertical\n",
      "            span rectangle in relative Y-axis units (0-1). Default to 1.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        rectangle : matplotlib.patches.Polygon\n",
      "            Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Optional parameters are properties of the class\n",
      "            matplotlib.patches.Polygon.\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(*args, **kwargs)\n",
      "        Make a bar plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "           bar(x, height, *, align='center', **kwargs)\n",
      "           bar(x, height, width, *, align='center', **kwargs)\n",
      "           bar(x, height, width, bottom, *, align='center', **kwargs)\n",
      "        \n",
      "        The bars are positioned at *x* with the given *align* ment. Their\n",
      "        dimensions are given by *width* and *height*. The vertical baseline\n",
      "        is *bottom* (default 0).\n",
      "        \n",
      "        Each of *x*, *height*, *width*, and *bottom* may either be a scalar\n",
      "        applying to all bars, or it may be a sequence of length N providing a\n",
      "        separate value for each bar.\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : sequence of scalars\n",
      "            The x coordinates of the bars. See also *align* for the\n",
      "            alignment of the bars to the coordinates.\n",
      "        \n",
      "        height : scalar or sequence of scalars\n",
      "            The height(s) of the bars.\n",
      "        \n",
      "        width : scalar or array-like, optional\n",
      "            The width(s) of the bars (default: 0.8).\n",
      "        \n",
      "        bottom : scalar or array-like, optional\n",
      "            The y coordinate(s) of the bars bases (default: 0).\n",
      "        \n",
      "        align : {'center', 'edge'}, optional, 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 : scalar or array-like, optional\n",
      "            The colors of the bar faces.\n",
      "        \n",
      "        edgecolor : scalar or array-like, optional\n",
      "            The colors of the bar edges.\n",
      "        \n",
      "        linewidth : scalar or array-like, optional\n",
      "            Width of the bar edge(s). If 0, don't draw edges.\n",
      "        \n",
      "        tick_label : string or array-like, optional\n",
      "            The tick labels of the bars.\n",
      "            Default: None (Use default numeric labels.)\n",
      "        \n",
      "        xerr, yerr : scalar 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\n",
      "        \n",
      "            Default: None\n",
      "        \n",
      "        ecolor : scalar or array-like, optional, default: 'black'\n",
      "            The line color of the errorbars.\n",
      "        \n",
      "        capsize : scalar, optional\n",
      "           The length of the error bar caps in points.\n",
      "           Default: None, which will take the value from\n",
      "           :rc:`errorbar.capsize`.\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, optional, default: False\n",
      "            If *True*, set the y-axis to be log scale.\n",
      "        \n",
      "        orientation : {'vertical',  'horizontal'}, optional\n",
      "            *This is for internal use only.* Please use `barh` for\n",
      "            horizontal bar plots. Default: 'vertical'.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        barh: Plot a horizontal bar plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The optional arguments *color*, *edgecolor*, *linewidth*,\n",
      "        *xerr*, and *yerr* can be either scalars or sequences of\n",
      "        length equal to the number of bars.  This enables you to use\n",
      "        bar as the basis for stacked bar charts, or candlestick plots.\n",
      "        Detail: *xerr* and *yerr* are passed directly to\n",
      "        :meth:`errorbar`, so they can also have shape 2xN for\n",
      "        independent specification of lower and upper errors.\n",
      "        \n",
      "        Other optional kwargs:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: bool or None \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `.Figure` instance \n",
      "          fill: bool \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'bottom', 'color', 'ecolor', 'edgecolor', 'height', 'left', 'linewidth', 'tick_label', 'width', 'x', 'xerr', 'y', 'yerr'.\n",
      "            * All positional arguments.\n",
      "    \n",
      "    barbs(*args, **kw)\n",
      "        Plot a 2-D field of barbs.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          barb(U, V, **kw)\n",
      "          barb(U, V, C, **kw)\n",
      "          barb(X, Y, U, V, **kw)\n",
      "          barb(X, Y, U, V, C, **kw)\n",
      "        \n",
      "        Arguments:\n",
      "        \n",
      "          *X*, *Y*:\n",
      "            The x and y coordinates of the barb locations\n",
      "            (default is head of barb; see *pivot* kwarg)\n",
      "        \n",
      "          *U*, *V*:\n",
      "            Give the x and y components of the barb shaft\n",
      "        \n",
      "          *C*:\n",
      "            An optional array used to map colors to the barbs\n",
      "        \n",
      "        All arguments may be 1-D or 2-D arrays or sequences. If *X* and *Y*\n",
      "        are absent, they will be generated as a uniform grid.  If *U* and *V*\n",
      "        are 2-D arrays but *X* and *Y* are 1-D, and if ``len(X)`` and ``len(Y)``\n",
      "        match the column and row dimensions of *U*, then *X* and *Y* will be\n",
      "        expanded with :func:`numpy.meshgrid`.\n",
      "        \n",
      "        *U*, *V*, *C* may be masked arrays, but masked *X*, *Y* are not\n",
      "        supported at present.\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *length*:\n",
      "            Length of the barb in points; the other parts of the barb\n",
      "            are scaled against this.\n",
      "            Default is 7.\n",
      "        \n",
      "          *pivot*: [ 'tip' | 'middle' | float ]\n",
      "            The part of the arrow that is at the grid point; the arrow rotates\n",
      "            about this point, hence the name *pivot*.  Default is 'tip'. Can\n",
      "            also be a number, which shifts the start of the barb that many\n",
      "            points from the origin.\n",
      "        \n",
      "          *barbcolor*: [ color | color sequence ]\n",
      "            Specifies the color all parts of the barb except any flags.  This\n",
      "            parameter is analogous to the *edgecolor* parameter for polygons,\n",
      "            which can be used instead. However this parameter will override\n",
      "            facecolor.\n",
      "        \n",
      "          *flagcolor*: [ color | color sequence ]\n",
      "            Specifies the color of any flags on the barb.  This parameter is\n",
      "            analogous to the *facecolor* parameter for polygons, which can be\n",
      "            used instead. However this parameter will override facecolor.  If\n",
      "            this is not set (and *C* has not either) then *flagcolor* will be\n",
      "            set to match *barbcolor* so that the barb has a uniform color. If\n",
      "            *C* has been set, *flagcolor* has no effect.\n",
      "        \n",
      "          *sizes*:\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",
      "        \n",
      "                - 'height' - height (distance from shaft to top) of a flag or\n",
      "                  full barb\n",
      "        \n",
      "                - 'width' - width of a flag, twice the width of a full barb\n",
      "        \n",
      "                - 'emptybarb' - radius of the circle used for low magnitudes\n",
      "        \n",
      "          *fill_empty*:\n",
      "            A flag on whether the empty barbs (circles) that are drawn should\n",
      "            be filled with the flag color.  If they are not filled, they will\n",
      "            be drawn such that no color is applied to the center.  Default is\n",
      "            False\n",
      "        \n",
      "          *rounding*:\n",
      "            A flag to indicate whether the vector magnitude should be rounded\n",
      "            when allocating barb components.  If True, the magnitude is\n",
      "            rounded to the nearest multiple of the half-barb increment.  If\n",
      "            False, the magnitude is simply truncated to the next lowest\n",
      "            multiple.  Default is True\n",
      "        \n",
      "          *barb_increments*:\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",
      "        \n",
      "                - 'full' - full barbs (Default is 10)\n",
      "        \n",
      "                - 'flag' - flags (default is 50)\n",
      "        \n",
      "          *flip_barb*:\n",
      "            Either a single boolean flag or an array of booleans.  Single\n",
      "            boolean indicates whether the lines and flags should point\n",
      "            opposite to normal for all barbs.  An array (which should be the\n",
      "            same size as the other data arrays) indicates whether to flip for\n",
      "            each individual barb.  Normal behavior is for the barbs and lines\n",
      "            to point right (comes from wind barbs having these features point\n",
      "            towards low pressure in the Northern Hemisphere.)  Default is\n",
      "            False\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",
      "        .. note the double \\\\ at the end of each line to make the figure\n",
      "        .. render correctly\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",
      "        linewidths and edgecolors can be used to customize the barb.\n",
      "        Additional :class:`~matplotlib.collections.PolyCollection` keyword\n",
      "        arguments:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    barh(*args, **kwargs)\n",
      "        Make a horizontal bar plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "           bar(y, width, *, align='center', **kwargs)\n",
      "           bar(y, width, height, *, align='center', **kwargs)\n",
      "           bar(y, width, height, left, *, align='center', **kwargs)\n",
      "        \n",
      "        The bars are positioned at *y* with the given *align*. Their\n",
      "        dimensions are given by *width* and *height*. The horizontal baseline\n",
      "        is *left* (default 0).\n",
      "        \n",
      "        Each of *y*, *width*, *height*, and *left* may either be a scalar\n",
      "        applying to all bars, or it may be a sequence of length N providing a\n",
      "        separate value for each bar.\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : scalar 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 : scalar or array-like\n",
      "            The width(s) of the bars.\n",
      "        \n",
      "        height : sequence of scalars, optional, default: 0.8\n",
      "            The heights of the bars.\n",
      "        \n",
      "        left : sequence of scalars\n",
      "            The x coordinates of the left sides of the bars (default: 0).\n",
      "        \n",
      "        align : {'center', 'edge'}, optional, 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 : scalar or array-like, optional\n",
      "            The colors of the bar faces.\n",
      "        \n",
      "        edgecolor : scalar or array-like, optional\n",
      "            The colors of the bar edges.\n",
      "        \n",
      "        linewidth : scalar or array-like, optional\n",
      "            Width of the bar edge(s). If 0, don't draw edges.\n",
      "        \n",
      "        tick_label : string or array-like, optional\n",
      "            The tick labels of the bars.\n",
      "            Default: None (Use default numeric labels.)\n",
      "        \n",
      "        xerr, yerr : scalar 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\n",
      "        \n",
      "            Default: None\n",
      "        \n",
      "        ecolor : scalar or array-like, optional, default: 'black'\n",
      "            The line color of the errorbars.\n",
      "        \n",
      "        capsize : scalar, optional\n",
      "           The length of the error bar caps in points.\n",
      "           Default: None, which will take the value from\n",
      "           :rc:`errorbar.capsize`.\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, optional, default: False\n",
      "            If ``True``, set the x-axis to be log scale.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        bar: Plot a vertical bar plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The optional arguments *color*, *edgecolor*, *linewidth*,\n",
      "        *xerr*, and *yerr* can be either scalars or sequences of\n",
      "        length equal to the number of bars.  This enables you to use\n",
      "        bar as the basis for stacked bar charts, or candlestick plots.\n",
      "        Detail: *xerr* and *yerr* are passed directly to\n",
      "        :meth:`errorbar`, so they can also have shape 2xN for\n",
      "        independent specification of lower and upper errors.\n",
      "        \n",
      "        Other optional kwargs:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: bool or None \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `.Figure` instance \n",
      "          fill: bool \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float\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.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        on : bool or None\n",
      "            The new axes box state.  If ``None``, toggle the state.\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_xticks=True, autorange=False, zorder=None, hold=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, optional (False)\n",
      "            If `True`, will produce a notched box plot. Otherwise, a\n",
      "            rectangular boxplot is produced. The notches represent the\n",
      "            confidence interval (CI) around the median. See the entry\n",
      "            for the ``bootstrap`` parameter for information regarding\n",
      "            how the locations of the notches are computed.\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. Enter an empty string\n",
      "            ('') if you don't want to show fliers. If `None`, then the\n",
      "            fliers default to 'b+'  If you want more control use the\n",
      "            flierprops kwarg.\n",
      "        \n",
      "        vert : bool, optional (True)\n",
      "            If `True` (default), makes the boxes vertical. If `False`,\n",
      "            everything is drawn horizontally.\n",
      "        \n",
      "        whis : float, sequence, or string (default = 1.5)\n",
      "            As a float, determines the reach of the whiskers to the beyond the\n",
      "            first and third quartiles. In other words, where IQR is the\n",
      "            interquartile range (`Q3-Q1`), the upper whisker will extend to\n",
      "            last datum less than `Q3 + whis*IQR`). Similarly, the lower whisker\n",
      "            will extend to the first datum greater than `Q1 - whis*IQR`.\n",
      "            Beyond the whiskers, data\n",
      "            are considered outliers and are plotted as individual\n",
      "            points. Set this to an unreasonably high value to force the\n",
      "            whiskers to show the min and max values. Alternatively, set\n",
      "            this to an ascending sequence of percentile (e.g., [5, 95])\n",
      "            to set the whiskers at specific percentiles of the data.\n",
      "            Finally, ``whis`` can be the string ``'range'`` to force the\n",
      "            whiskers to the min and max of the data.\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 : array-like, optional\n",
      "            An array or sequence whose first dimension (or length) is\n",
      "            compatible with ``x``. This overrides the medians computed\n",
      "            by matplotlib for each element of ``usermedians`` that is not\n",
      "            `None`. When an element of ``usermedians`` is None, the median\n",
      "            will be computed by matplotlib as normal.\n",
      "        \n",
      "        conf_intervals : array-like, optional\n",
      "            Array or sequence whose first dimension (or length) is\n",
      "            compatible with ``x`` and whose second dimension is 2. When\n",
      "            the an element of ``conf_intervals`` is not None, the\n",
      "            notch locations computed by matplotlib are overridden\n",
      "            (provided ``notch`` is `True`). When an element of\n",
      "            ``conf_intervals`` is `None`, the notches are computed by the\n",
      "            method specified by the other kwargs (e.g., ``bootstrap``).\n",
      "        \n",
      "        positions : array-like, optional\n",
      "            Sets 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 : scalar or array-like\n",
      "            Sets the width of each box either with a scalar or a\n",
      "            sequence. The default is 0.5, or ``0.15*(distance between\n",
      "            extreme positions)``, if that is smaller.\n",
      "        \n",
      "        patch_artist : bool, optional (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. Length must be compatible with\n",
      "            dimensions  of ``x``.\n",
      "        \n",
      "        manage_xticks : bool, optional (True)\n",
      "            If the function should adjust the xlim and xtick locations.\n",
      "        \n",
      "        autorange : bool, optional (False)\n",
      "            When `True` and the data are distributed such that the  25th and\n",
      "            75th percentiles are equal, ``whis`` is set to ``'range'`` such\n",
      "            that the whisker ends are at the minimum and maximum of the\n",
      "            data.\n",
      "        \n",
      "        meanline : bool, optional (False)\n",
      "            If `True` (and ``showmeans`` is `True`), will try to render\n",
      "            the mean as a line spanning the full width of the box\n",
      "            according to ``meanprops`` (see below). Not recommended if\n",
      "            ``shownotches`` is also True. Otherwise, means will be shown\n",
      "            as points.\n",
      "        \n",
      "        zorder : scalar, optional (None)\n",
      "            Sets the zorder of the boxplot.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        showcaps : bool, optional (True)\n",
      "            Show the caps on the ends of whiskers.\n",
      "        showbox : bool, optional (True)\n",
      "            Show the central box.\n",
      "        showfliers : bool, optional (True)\n",
      "            Show the outliers beyond the caps.\n",
      "        showmeans : bool, optional (False)\n",
      "            Show the arithmetic means.\n",
      "        capprops : dict, optional (None)\n",
      "            Specifies the style of the caps.\n",
      "        boxprops : dict, optional (None)\n",
      "            Specifies the style of the box.\n",
      "        whiskerprops : dict, optional (None)\n",
      "            Specifies the style of the whiskers.\n",
      "        flierprops : dict, optional (None)\n",
      "            Specifies the style of the fliers.\n",
      "        medianprops : dict, optional (None)\n",
      "            Specifies the style of the median.\n",
      "        meanprops : dict, optional (None)\n",
      "            Specifies the style of the mean.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        result : dict\n",
      "          A dictionary mapping each component of the boxplot to a list\n",
      "          of the :class:`matplotlib.lines.Line2D` instances\n",
      "          created. That dictionary has the following keys (assuming\n",
      "          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",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    broken_barh(xranges, yrange, hold=None, 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",
      "        yranges : (*ymin*, *ymax*)\n",
      "            The y-position and extend for all the rectangles.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : :class:`.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",
      "              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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`matplotlib.collections.BrokenBarHCollection`\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    cla()\n",
      "        Clear the current axes.\n",
      "    \n",
      "    clabel(CS, *args, **kwargs)\n",
      "        Label a contour plot.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          clabel(cs, **kwargs)\n",
      "        \n",
      "        Adds labels to line contours in *cs*, where *cs* is a\n",
      "        :class:`~matplotlib.contour.ContourSet` object returned by\n",
      "        contour.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          clabel(cs, v, **kwargs)\n",
      "        \n",
      "        only labels contours listed in *v*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fontsize : string or float, optional\n",
      "            Size in points or relative size e.g., 'smaller', 'x-large'.\n",
      "            See `Text.set_size` for accepted string values.\n",
      "        \n",
      "        colors :\n",
      "            Color of each label\n",
      "        \n",
      "            - if *None*, the color of each label matches the color of\n",
      "              the corresponding contour\n",
      "        \n",
      "            - if one string color, e.g., *colors* = 'r' or *colors* =\n",
      "              'red', all labels will be plotted in this color\n",
      "        \n",
      "            - if a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "              different labels will be plotted in different colors in the order\n",
      "              specified\n",
      "        \n",
      "        inline : bool, optional\n",
      "            If ``True`` the underlying contour is removed where the label is\n",
      "            placed. Default is ``True``.\n",
      "        \n",
      "        inline_spacing : float, optional\n",
      "            Space in pixels to leave on each side of label when\n",
      "            placing inline. Defaults to 5.\n",
      "        \n",
      "            This spacing will be exact for labels at locations where the\n",
      "            contour is straight, less so for labels on curved contours.\n",
      "        \n",
      "        fmt : string or dict, optional\n",
      "            A format string for the label. Default is '%1.3f'\n",
      "        \n",
      "            Alternatively, this can be a dictionary matching contour\n",
      "            levels with arbitrary strings to use for each contour level\n",
      "            (i.e., fmt[level]=string), or it can be any callable, such\n",
      "            as a :class:`~matplotlib.ticker.Formatter` instance, that\n",
      "            returns a string when called with a numeric contour level.\n",
      "        \n",
      "        manual : bool or iterable, optional\n",
      "            If ``True``, contour labels will be placed manually using\n",
      "            mouse clicks. Click the first button near a contour to\n",
      "            add a label, click the second button (or potentially both\n",
      "            mouse buttons at once) to finish adding labels. The third\n",
      "            button can be used to remove the last label added, but\n",
      "            only if labels are not inline. Alternatively, the keyboard\n",
      "            can be used to select label locations (enter to end label\n",
      "            placement, delete or backspace act like the third mouse button,\n",
      "            and any other key will select a label location).\n",
      "        \n",
      "            *manual* can also be an iterable object of x,y tuples.\n",
      "            Contour labels will be created as if mouse is clicked at each\n",
      "            x,y positions.\n",
      "        \n",
      "        rightside_up : bool, optional\n",
      "            If ``True``, label rotations will always be plus\n",
      "            or minus 90 degrees from level. Default is ``True``.\n",
      "        \n",
      "        use_clabeltext : bool, optional\n",
      "            If ``True``, `ClabelText` class (instead of `Text`) is used to\n",
      "            create labels. `ClabelText` recalculates rotation angles\n",
      "            of texts during the drawing time, therefore this can be used if\n",
      "            aspect of the axes changes. Default is ``False``.\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",
      "        To apply clim to all axes images do::\n",
      "        \n",
      "          clim(0, 0.5)\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,\n",
      "        use, for example::\n",
      "        \n",
      "          for im in gca().get_images():\n",
      "              im.set_clim(0, 0.05)\n",
      "    \n",
      "    close(*args)\n",
      "        Close a figure window.\n",
      "        \n",
      "        ``close()`` by itself closes the current figure\n",
      "        \n",
      "        ``close(fig)`` closes the `.Figure` instance *fig*\n",
      "        \n",
      "        ``close(num)`` closes the figure number *num*\n",
      "        \n",
      "        ``close(name)`` where *name* is a string, closes figure with that label\n",
      "        \n",
      "        ``close('all')`` closes all the figure windows\n",
      "    \n",
      "    cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0x7f21a053a0d0>, window=<function window_hanning at 0x7f21a0518bf8>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, hold=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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between blocks.  The\n",
      "            default value is 0 (no overlap).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        The return value is a tuple (*Cxy*, *f*), where *f* are the\n",
      "        frequencies of the coherence vector.\n",
      "        \n",
      "        kwargs are applied to the lines.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \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",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    colorbar(mappable=None, cax=None, ax=None, **kw)\n",
      "        Add a colorbar to a plot.\n",
      "        \n",
      "        Function signatures for the :mod:`~matplotlib.pyplot` interface; all\n",
      "        but the first are also method signatures for the\n",
      "        :meth:`~matplotlib.figure.Figure.colorbar` method::\n",
      "        \n",
      "          colorbar(**kwargs)\n",
      "          colorbar(mappable, **kwargs)\n",
      "          colorbar(mappable, cax=cax, **kwargs)\n",
      "          colorbar(mappable, ax=ax, **kwargs)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mappable :\n",
      "            The :class:`~matplotlib.image.Image`,\n",
      "            :class:`~matplotlib.contour.ContourSet`, etc. to\n",
      "            which the colorbar applies; this argument is mandatory for the Figure\n",
      "            :meth:`~matplotlib.figure.Figure.colorbar` method but optional for the\n",
      "            pyplot :func:`~matplotlib.pyplot.colorbar` function, which sets the\n",
      "            default to the current image.\n",
      "        \n",
      "        cax : :class:`~matplotlib.axes.Axes` object, optional\n",
      "            Axis into which the colorbar will be drawn\n",
      "        \n",
      "        ax : :class:`~matplotlib.axes.Axes`, list of Axes, optional\n",
      "            Parent axes from which space for a new colorbar axes will be stolen.\n",
      "            If a list of axes is given they will all be resized to make room for the\n",
      "            colorbar axes.\n",
      "        \n",
      "        use_gridspec : bool, optional\n",
      "            If *cax* is ``None``, a new *cax* is created as an instance of\n",
      "            Axes. If *ax* is an instance of Subplot and *use_gridspec* is ``True``,\n",
      "            *cax* is created as an instance of Subplot using the\n",
      "            grid_spec module.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`~matplotlib.colorbar.Colorbar` instance\n",
      "            See also its base class, :class:`~matplotlib.colorbar.ColorbarBase`.\n",
      "            Call the :meth:`~matplotlib.colorbar.ColorbarBase.set_label` method\n",
      "            to label the colorbar.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Additional keyword arguments are of two kinds:\n",
      "        \n",
      "          axes properties:\n",
      "        \n",
      "        \n",
      "            ============= ====================================================\n",
      "            Property      Description\n",
      "            ============= ====================================================\n",
      "            *orientation* vertical or horizontal\n",
      "            *fraction*    0.15; fraction of original axes to use for colorbar\n",
      "            *pad*         0.05 if vertical, 0.15 if horizontal; fraction\n",
      "                          of original axes between colorbar and new image axes\n",
      "            *shrink*      1.0; fraction by which to multiply the size of the colorbar\n",
      "            *aspect*      20; ratio of long to short dimensions\n",
      "            *anchor*      (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal;\n",
      "                          the anchor point of the colorbar axes\n",
      "            *panchor*     (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal;\n",
      "                          the anchor point of the colorbar parent axes. If\n",
      "                          False, the parent axes' anchor will be unchanged\n",
      "            ============= ====================================================\n",
      "        \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 | list of ticks | Locator object ]\n",
      "                          If None, ticks are determined automatically from the\n",
      "                          input.\n",
      "            *format*      [ None | format string | Formatter object ]\n",
      "                          If None, the\n",
      "                          :class:`~matplotlib.ticker.ScalarFormatter` is used.\n",
      "                          If a format string is given, e.g., '%.3f', that is\n",
      "                          used. An alternative\n",
      "                          :class:`~matplotlib.ticker.Formatter` object may be\n",
      "                          given instead.\n",
      "            *drawedges*   bool\n",
      "                          Whether to draw lines at color boundaries.\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",
      "                           color mapped to the corresponding value in values\n",
      "                           will be used.\n",
      "            ============   ===================================================\n",
      "        \n",
      "        \n",
      "        \n",
      "        If *mappable* is a :class:`~matplotlib.contours.ContourSet`, its *extend*\n",
      "        kwarg is included 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 viewer (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. Particularly\n",
      "        with semi transparent images (alpha < 1) and colorbar extensions and is not\n",
      "        enabled 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 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",
      "          meant for plotting values that wrap around at the\n",
      "          endpoints, such as phase 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 color maps which are\n",
      "        the recommended color maps 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",
      "        <http://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, :class:`ListedColormap` is used,\n",
      "        not :class:`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 color map 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",
      "          hsv         cyclic red-yellow-green-cyan-blue-magenta-red, formed\n",
      "                      by changing the hue component in the HSV color space\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",
      "        \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",
      "          ============= =======================================================\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",
      "          spectral   identical to *nipy_spectral* [#]_\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",
      "          <http://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",
      "        .. [#] Changed to distinguish from ColorBrewer's *Spectral* map.\n",
      "          :func:`spectral` still works, but\n",
      "          ``set_cmap('nipy_spectral')`` is recommended for clarity.\n",
      "    \n",
      "    colors()\n",
      "        .. deprecated:: 2.1\n",
      "            The colors function was deprecated in version 2.1.\n",
      "        \n",
      "        This is a do-nothing function to provide you with help on how\n",
      "        matplotlib handles colors.\n",
      "        \n",
      "        Commands which take color arguments can use several formats to\n",
      "        specify the colors.  For the basic built-in colors, you can use a\n",
      "        single letter\n",
      "        \n",
      "          =====   =======\n",
      "          Alias   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",
      "        For a greater range of colors, you have two options.  You can\n",
      "        specify the color using an html hex string, as in::\n",
      "        \n",
      "          color = '#eeefff'\n",
      "        \n",
      "        or you can pass an R,G,B tuple, where each of R,G,B are in the\n",
      "        range [0,1].\n",
      "        \n",
      "        You can also use any legal html name for a color, for example::\n",
      "        \n",
      "          color = 'red'\n",
      "          color = 'burlywood'\n",
      "          color = 'chartreuse'\n",
      "        \n",
      "        The example below creates a subplot with a dark\n",
      "        slate gray background::\n",
      "        \n",
      "           subplot(111, facecolor=(0.1843, 0.3098, 0.3098))\n",
      "        \n",
      "        Here is an example that creates a pale turquoise title::\n",
      "        \n",
      "          title('Is this the best color?', color='#afeeee')\n",
      "    \n",
      "    connect(s, func)\n",
      "        Connect event with string *s* to *func*.  The signature of *func* is::\n",
      "        \n",
      "          def func(event)\n",
      "        \n",
      "        where event is a :class:`matplotlib.backend_bases.Event`.  The\n",
      "        following events are recognized\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",
      "        For the location events (button and key press/release), if the\n",
      "        mouse is over the axes, the variable ``event.inaxes`` will be\n",
      "        set to the :class:`~matplotlib.axes.Axes` the event occurs is\n",
      "        over, and additionally, the variables ``event.xdata`` and\n",
      "        ``event.ydata`` will be defined.  This is the mouse location\n",
      "        in data coords.  See\n",
      "        :class:`~matplotlib.backend_bases.KeyEvent` and\n",
      "        :class:`~matplotlib.backend_bases.MouseEvent` for more info.\n",
      "        \n",
      "        Return value is a connection id that can be used with\n",
      "        :meth:`~matplotlib.backend_bases.Event.mpl_disconnect`.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Usage::\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, **kwargs)\n",
      "        Plot contours.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contour` and\n",
      "        :func:`~matplotlib.pyplot.contourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contourf` differs from the MATLAB\n",
      "        version in that it does not draw the polygon edges.\n",
      "        To draw edges, add line contours with\n",
      "        calls to :func:`~matplotlib.pyplot.contour`.\n",
      "        \n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          contour(Z)\n",
      "        \n",
      "        make a contour plot of an array *Z*. The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(X,Y,Z)\n",
      "        \n",
      "        *X*, *Y* specify the (x, y) coordinates of the surface\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,N)\n",
      "          contour(X,Y,Z,N)\n",
      "        \n",
      "        contour up to *N+1* automatically chosen contour levels\n",
      "        (*N* intervals).\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,V)\n",
      "          contour(X,Y,Z,V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contourf(..., V)\n",
      "        \n",
      "        fill the ``len(V)-1`` regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        *X* and *Y* must both be 2-D with the same shape as *Z*, or they\n",
      "        must both be 1-D such that ``len(X)`` is the number of columns in\n",
      "        *Z* and ``len(Y)`` is the number of rows in *Z*.\n",
      "        \n",
      "        ``C = contour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.QuadContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *corner_mask*: bool, optional\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",
      "            Defaults to ``rcParams['contour.corner_mask']``, which defaults to\n",
      "            ``True``.\n",
      "        \n",
      "          *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "          *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "          *vmin*, *vmax*: [ *None* | scalar ]\n",
      "            If not *None*, either or both of these values will be\n",
      "            supplied to the :class:`matplotlib.colors.Normalize`\n",
      "            instance, overriding the default color scaling based on\n",
      "            *levels*.\n",
      "        \n",
      "          *levels*: [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "          *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is *None*, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "          *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "          *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "          *antialiased*: bool\n",
      "            enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from rcParams['lines.antialiased'].\n",
      "        \n",
      "          *nchunk*: [ 0 | integer ]\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",
      "        contour-only keyword arguments:\n",
      "        \n",
      "          *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified.\n",
      "        \n",
      "          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the default is 'solid' unless\n",
      "            the lines are monochrome.  In that case, negative\n",
      "            contours will take their linestyle from the ``matplotlibrc``\n",
      "            ``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",
      "        contourf-only keyword arguments:\n",
      "        \n",
      "          *hatches*:\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",
      "        \n",
      "        Note: contourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    contourf(*args, **kwargs)\n",
      "        Plot contours.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contour` and\n",
      "        :func:`~matplotlib.pyplot.contourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contourf` differs from the MATLAB\n",
      "        version in that it does not draw the polygon edges.\n",
      "        To draw edges, add line contours with\n",
      "        calls to :func:`~matplotlib.pyplot.contour`.\n",
      "        \n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          contour(Z)\n",
      "        \n",
      "        make a contour plot of an array *Z*. The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(X,Y,Z)\n",
      "        \n",
      "        *X*, *Y* specify the (x, y) coordinates of the surface\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,N)\n",
      "          contour(X,Y,Z,N)\n",
      "        \n",
      "        contour up to *N+1* automatically chosen contour levels\n",
      "        (*N* intervals).\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,V)\n",
      "          contour(X,Y,Z,V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contourf(..., V)\n",
      "        \n",
      "        fill the ``len(V)-1`` regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        *X* and *Y* must both be 2-D with the same shape as *Z*, or they\n",
      "        must both be 1-D such that ``len(X)`` is the number of columns in\n",
      "        *Z* and ``len(Y)`` is the number of rows in *Z*.\n",
      "        \n",
      "        ``C = contour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.QuadContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *corner_mask*: bool, optional\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",
      "            Defaults to ``rcParams['contour.corner_mask']``, which defaults to\n",
      "            ``True``.\n",
      "        \n",
      "          *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "          *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "          *vmin*, *vmax*: [ *None* | scalar ]\n",
      "            If not *None*, either or both of these values will be\n",
      "            supplied to the :class:`matplotlib.colors.Normalize`\n",
      "            instance, overriding the default color scaling based on\n",
      "            *levels*.\n",
      "        \n",
      "          *levels*: [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "          *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is *None*, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "          *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "          *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "          *antialiased*: bool\n",
      "            enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from rcParams['lines.antialiased'].\n",
      "        \n",
      "          *nchunk*: [ 0 | integer ]\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",
      "        contour-only keyword arguments:\n",
      "        \n",
      "          *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified.\n",
      "        \n",
      "          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the default is 'solid' unless\n",
      "            the lines are monochrome.  In that case, negative\n",
      "            contours will take their linestyle from the ``matplotlibrc``\n",
      "            ``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",
      "        contourf-only keyword arguments:\n",
      "        \n",
      "          *hatches*:\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",
      "        \n",
      "        Note: contourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\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, hold=None, data=None, **kwargs)\n",
      "        Plot the cross-spectral density.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          csd(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n",
      "              window=mlab.window_hanning, noverlap=0, pad_to=None,\n",
      "              sides='default', scale_by_freq=None, return_line=None, **kwargs)\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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between segments.\n",
      "            The default value is 0 (no overlap).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        return_line : bool\n",
      "            Whether to include the line object plotted in the returned values.\n",
      "            Default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Pxy : 1-D array\n",
      "            The values for the cross spectrum `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 : a :class:`~matplotlib.lines.Line2D` instance\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 :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`psd`\n",
      "            :func:`psd` is the 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 `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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    delaxes(ax=None)\n",
      "        Remove the given `Axes` *ax* from the current figure. If *ax* is *None*,\n",
      "        the current axes is removed. A KeyError is raised if the axes doesn't exist.\n",
      "    \n",
      "    disconnect(cid)\n",
      "        Disconnect callback id cid\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Usage::\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 (:func:`.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\n",
      "        bugs.\n",
      "        \n",
      "        A more object-oriented alternative, given any\n",
      "        :class:`~matplotlib.figure.Figure` instance, :attr:`fig`, that\n",
      "        was created using a :mod:`~matplotlib.pyplot` function, is::\n",
      "        \n",
      "            fig.canvas.draw_idle()\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, hold=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 : scalar or array-like\n",
      "            The data positions.\n",
      "        \n",
      "        xerr, yerr : scalar 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 data point.\n",
      "            - *None*: No errorbar.\n",
      "        \n",
      "        fmt : plot format string, optional, 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 : mpl color, optional, default: None\n",
      "            A matplotlib color arg which gives the color the errorbar lines.\n",
      "            If None, use the color of the line connecting the markers.\n",
      "        \n",
      "        elinewidth : scalar, optional, default: None\n",
      "            The linewidth of the errorbar lines. If None, the linewidth of\n",
      "            the current style is used.\n",
      "        \n",
      "        capsize : scalar, optional, default: None\n",
      "            The length of the error bar caps in points. If None, it will take\n",
      "            the value from :rc:`errorbar.capsize`.\n",
      "        \n",
      "        capthick : scalar, optional, 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, optional, default: False\n",
      "            If True, will plot the errorbars above the plot\n",
      "            symbols. Default is below.\n",
      "        \n",
      "        lolims, uplims, xlolims, xuplims : bool, optional, default: None\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 of the same type as *xerr*\n",
      "            and *yerr*.  To use limits with inverted axes, :meth:`set_xlim`\n",
      "            or :meth:`set_ylim` must be called before :meth:`errorbar`.\n",
      "        \n",
      "        errorevery : positive integer, optional, default: 1\n",
      "            Subsamples the errorbars. e.g., if errorevery=5, errorbars for\n",
      "            every 5-th datapoint will be plotted. The data plot itself still\n",
      "            shows all data points.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`~.container.ErrorbarContainer`\n",
      "            The container contains:\n",
      "        \n",
      "            - plotline: :class:`~matplotlib.lines.Line2D` instance of\n",
      "              x, y plot markers and/or line.\n",
      "            - caplines: A tuple of :class:`~matplotlib.lines.Line2D` instances\n",
      "              of the error bar caps.\n",
      "            - barlinecols: A tuple of\n",
      "              :class:`~matplotlib.collections.LineCollection` with the\n",
      "              horizontal and vertical error ranges.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            All other keyword arguments are passed on to the plot\n",
      "            command for the markers. For example, this code makes big red\n",
      "            squares 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 `.Lines2D` properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'xerr', 'y', 'yerr'.\n",
      "    \n",
      "    eventplot(positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', hold=None, data=None, **kwargs)\n",
      "        Plot identical parallel lines at the given positions.\n",
      "        \n",
      "        *positions* should be a 1D or 2D array-like object, with each row\n",
      "        corresponding to a row or column of lines.\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 : 1D or 2D array-like object\n",
      "            Each value is an event. If *positions* is a 2D array-like, each\n",
      "            row corresponds to a row or a column of lines (depending on the\n",
      "            *orientation* parameter).\n",
      "        \n",
      "        orientation : {'horizontal', 'vertical'}, optional\n",
      "            Controls the direction of the event collections:\n",
      "        \n",
      "                - 'horizontal' : the lines are arranged horizontally in rows,\n",
      "                  and are vertical.\n",
      "                - 'vertical' : the lines are arranged vertically in columns,\n",
      "                  and are horizontal.\n",
      "        \n",
      "        lineoffsets : scalar or sequence of scalars, optional, default: 1\n",
      "            The offset of the center of the lines from the origin, in the\n",
      "            direction orthogonal to *orientation*.\n",
      "        \n",
      "        linelengths : scalar or sequence of scalars, optional, 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",
      "        linewidths : scalar, scalar sequence or None, optional, default: None\n",
      "            The line width(s) of the event lines, in points. If it is None,\n",
      "            defaults to its rcParams setting.\n",
      "        \n",
      "        colors : color, sequence of colors or None, optional, default: None\n",
      "            The color(s) of the event lines. If it is None, defaults to its\n",
      "            rcParams setting.\n",
      "        \n",
      "        linestyles : str or tuple or a sequence of such values, optional\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",
      "        **kwargs : optional\n",
      "            Other keyword arguments are line collection properties.  See\n",
      "            :class:`~matplotlib.collections.LineCollection` for a list of\n",
      "            the valid properties.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        \n",
      "        A list of :class:`matplotlib.collections.EventCollection` objects that\n",
      "        were added.\n",
      "        \n",
      "        Notes\n",
      "        -----\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",
      "        \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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'linelengths', 'lineoffsets', 'linestyles', 'linewidths', 'positions'.\n",
      "    \n",
      "    figimage(*args, **kwargs)\n",
      "        Adds a non-resampled image to the figure.\n",
      "        \n",
      "        call signatures::\n",
      "        \n",
      "          figimage(X, **kwargs)\n",
      "        \n",
      "        adds a non-resampled array *X* to the figure.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          figimage(X, xo, yo)\n",
      "        \n",
      "        with pixel offsets *xo*, *yo*,\n",
      "        \n",
      "        *X* must be a float array:\n",
      "        \n",
      "        * If *X* is MxN, assume luminance (grayscale)\n",
      "        * If *X* is MxNx3, assume RGB\n",
      "        * If *X* is MxNx4, assume RGBA\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          =========   =========================================================\n",
      "          Keyword     Description\n",
      "          =========   =========================================================\n",
      "          resize      a boolean, True or False. If \"True\", then re-size the\n",
      "                      Figure to match the given image size.\n",
      "          xo or yo    An integer, the *x* and *y* image offset in pixels\n",
      "          cmap        a :class:`matplotlib.colors.Colormap` instance, e.g.,\n",
      "                      cm.jet. If *None*, default to the rc ``image.cmap``\n",
      "                      value\n",
      "          norm        a :class:`matplotlib.colors.Normalize` instance. The\n",
      "                      default is normalization().  This scales luminance -> 0-1\n",
      "          vmin|vmax   are used to scale a luminance image to 0-1.  If either\n",
      "                      is *None*, the min and max of the luminance values will\n",
      "                      be used.  Note if you pass a norm instance, the settings\n",
      "                      for *vmin* and *vmax* will be ignored.\n",
      "          alpha       the alpha blending value, default is *None*\n",
      "          origin      [ 'upper' | 'lower' ] Indicates where the [0,0] index of\n",
      "                      the array is in the upper left or lower left corner of\n",
      "                      the axes. Defaults to the rc image.origin value\n",
      "          =========   =========================================================\n",
      "        \n",
      "        figimage complements the axes image\n",
      "        (:meth:`~matplotlib.axes.Axes.imshow`) which will be resampled\n",
      "        to fit the current axes.  If you want a resampled image to\n",
      "        fill the entire figure, you can define an\n",
      "        :class:`~matplotlib.axes.Axes` with extent [0,0,1,1].\n",
      "        \n",
      "        An :class:`matplotlib.image.FigureImage` instance is returned.\n",
      "        \n",
      "        Additional kwargs are Artist kwargs passed on to\n",
      "        :class:`~matplotlib.image.FigureImage`\n",
      "    \n",
      "    figlegend(*args, **kwargs)\n",
      "        Place a legend in the figure.\n",
      "        \n",
      "        *labels*\n",
      "          a sequence of strings\n",
      "        \n",
      "        *handles*\n",
      "          a sequence of :class:`~matplotlib.lines.Line2D` or\n",
      "          :class:`~matplotlib.patches.Patch` instances\n",
      "        \n",
      "        *loc*\n",
      "          can be a string or an integer specifying the legend\n",
      "          location\n",
      "        \n",
      "        A :class:`matplotlib.legend.Legend` instance is returned.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        To make a legend from existing artists on every axes::\n",
      "        \n",
      "          figlegend()\n",
      "        \n",
      "        To make a legend for a list of lines and labels::\n",
      "        \n",
      "          figlegend( (line1, line2, line3),\n",
      "                     ('label1', 'label2', 'label3'),\n",
      "                     'upper right' )\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "           :func:`~matplotlib.pyplot.legend`\n",
      "    \n",
      "    fignum_exists(num)\n",
      "    \n",
      "    figtext(*args, **kwargs)\n",
      "        Add text to figure.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          text(x, y, s, fontdict=None, **kwargs)\n",
      "        \n",
      "        Add text to figure at location *x*, *y* (relative 0-1\n",
      "        coords). See :func:`~matplotlib.pyplot.text` for the meaning\n",
      "        of the other arguments.\n",
      "        \n",
      "        kwargs control the :class:`~matplotlib.text.Text` properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          backgroundcolor: any matplotlib color \n",
      "          bbox: FancyBboxPatch prop dict \n",
      "          clip_box: a :class:`matplotlib.transforms.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [ (:class:`~matplotlib.path.Path`, :class:`~matplotlib.transforms.Transform`) | :class:`~matplotlib.patches.Patch` | None ] \n",
      "          color: any matplotlib color \n",
      "          contains: a callable function \n",
      "          family or fontfamily or fontname or name: [FONTNAME | 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ] \n",
      "          figure: a `.Figure` instance \n",
      "          fontproperties or font_properties: a :class:`matplotlib.font_manager.FontProperties` instance \n",
      "          gid: an id string \n",
      "          horizontalalignment or ha: [ 'center' | 'right' | 'left' ] \n",
      "          label: object \n",
      "          linespacing: float (multiple of font size) \n",
      "          multialignment or ma: ['left' | 'right' | 'center' ] \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          position: (x,y) \n",
      "          rasterized: bool or None \n",
      "          rotation: [ angle in degrees | 'vertical' | 'horizontal' ] \n",
      "          rotation_mode: [ None | \"default\" | \"anchor\" ]\n",
      "          size or fontsize: [size in points | 'xx-small' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'xx-large' ] \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          stretch or fontstretch: [a numeric value in range 0-1000 | 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'normal' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded' ] \n",
      "          style or fontstyle: [ 'normal' | 'italic' | 'oblique'] \n",
      "          text: string or anything printable with '%s' conversion. \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          usetex: bool or None \n",
      "          variant or fontvariant: [ 'normal' | 'small-caps' ] \n",
      "          verticalalignment or va: [ 'center' | 'top' | 'bottom' | 'baseline' ] \n",
      "          visible: bool \n",
      "          weight or fontweight: [a numeric value in range 0-1000 | 'ultralight' | 'light' | 'normal' | 'regular' | 'book' | 'medium' | 'roman' | 'semibold' | 'demibold' | 'demi' | 'bold' | 'heavy' | 'extra bold' | 'black' ] \n",
      "          wrap: bool \n",
      "          x: float \n",
      "          y: float \n",
      "          zorder: float\n",
      "    \n",
      "    figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True, FigureClass=<class 'matplotlib.figure.Figure'>, clear=False, **kwargs)\n",
      "        Creates a new figure.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        num : integer or string, optional, default: none\n",
      "            If not provided, a new figure will be created, and the figure number\n",
      "            will be incremented. The figure objects holds this number in a `number`\n",
      "            attribute.\n",
      "            If num is provided, and a figure with this id already exists, make\n",
      "            it active, and returns a reference to it. If this figure does not\n",
      "            exists, create it and returns it.\n",
      "            If num is a string, the window title will be set to this figure's\n",
      "            `num`.\n",
      "        \n",
      "        figsize : tuple of integers, optional, default: None\n",
      "            width, height in inches. If not provided, defaults to rc\n",
      "            figure.figsize.\n",
      "        \n",
      "        dpi : integer, optional, default: None\n",
      "            resolution of the figure. If not provided, defaults to rc figure.dpi.\n",
      "        \n",
      "        facecolor :\n",
      "            the background color. If not provided, defaults to rc figure.facecolor.\n",
      "        \n",
      "        edgecolor :\n",
      "            the border color. If not provided, defaults to rc figure.edgecolor.\n",
      "        \n",
      "        frameon : bool, optional, default: True\n",
      "            If False, suppress drawing the figure frame.\n",
      "        \n",
      "        FigureClass : class derived from matplotlib.figure.Figure\n",
      "            Optionally use a custom Figure instance.\n",
      "        \n",
      "        clear : bool, optional, default: False\n",
      "            If True and the figure already exists, then it is cleared.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        figure : Figure\n",
      "            The Figure instance returned will also be passed to new_figure_manager\n",
      "            in the backends, which allows to hook custom Figure classes into the\n",
      "            pylab interface. Additional kwargs will be passed to the figure init\n",
      "            function.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If you are creating many figures, make sure you explicitly call \"close\"\n",
      "        on the figures you are not using, because this will enable pylab\n",
      "        to properly clean up the memory.\n",
      "        \n",
      "        rcParams defines the default values, which can be modified in the\n",
      "        matplotlibrc file\n",
      "    \n",
      "    fill(*args, **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 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",
      "        Returns\n",
      "        -------\n",
      "        a list of :class:`~matplotlib.patches.Polygon`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : :class:`~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",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    fill_between(x, y1, y2=0, where=None, interpolate=False, step=None, hold=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*, *y2*). This\n",
      "        creates one or multiple polygons describing the filled 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* if\n",
      "        the filling should be a step function, i.e. constant in between *x*.\n",
      "        \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, optional, default: 0\n",
      "            The y coordinates of the nodes defining the second curve.\n",
      "        \n",
      "        where : array of bool (length N), optional, default: None\n",
      "            Define *where* to exclude some horizontal regions from being\n",
      "            filled. The filled regions are defined by the coordinates\n",
      "            ``x[where]``.  More precisely, fill between ``x[i]`` and ``x[i+1]``\n",
      "            if ``where[i] and where[i+1]``.  Note that this definition implies\n",
      "            that an isolated *True* value between two *False* values in\n",
      "            *where* will not result in filling.  Both sides of the *True*\n",
      "            position remain unfilled due to the adjacent *False* values.\n",
      "        \n",
      "        interpolate : bool, optional\n",
      "            This option is only relvant if *where* is used and the two curves\n",
      "            are crossing each other.\n",
      "        \n",
      "            Semantically, *where* is often used for *y1* > *y2* or similar.\n",
      "            By default, the nodes of the polygon defining the filled region\n",
      "            will only be placed at the positions in the *x* array.  Such a\n",
      "            polygon cannot describe the above semantics close to the\n",
      "            intersection.  The x-sections containing the intersecion are\n",
      "            simply clipped.\n",
      "        \n",
      "            Setting *interpolate* to *True* will calculate the actual\n",
      "            interscection 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",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All other keyword arguments are passed on to `.PolyCollection`.\n",
      "            They control the `.Polygon` properties:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.PolyCollection`\n",
      "            A `.PolyCollection` containing the plotted polygons.\n",
      "        \n",
      "        See Also\n",
      "        --------\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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'where', 'x', 'y1', 'y2'.\n",
      "    \n",
      "    fill_betweenx(y, x1, x2=0, where=None, step=None, interpolate=False, hold=None, data=None, **kwargs)\n",
      "        Fill the area between two vertical curves.\n",
      "        \n",
      "        The curves are defined by the points (*x1*, *y*) and (*x2*, *y*). This\n",
      "        creates one or multiple polygons describing the filled 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* if\n",
      "        the filling should be a step function, i.e. constant in between *y*.\n",
      "        \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, optional, default: 0\n",
      "            The x coordinates of the nodes defining the second curve.\n",
      "        \n",
      "        where : array of bool (length N), optional, default: None\n",
      "            Define *where* to exclude some vertical regions from being\n",
      "            filled. The filled regions are defined by the coordinates\n",
      "            ``y[where]``.  More precisely, fill between ``y[i]`` and ``y[i+1]``\n",
      "            if ``where[i] and where[i+1]``.  Note that this definition implies\n",
      "            that an isolated *True* value between two *False* values in\n",
      "            *where* will not result in filling.  Both sides of the *True*\n",
      "            position remain unfilled due to the adjacent *False* values.\n",
      "        \n",
      "        interpolate : bool, optional\n",
      "            This option is only relvant if *where* is used and the two curves\n",
      "            are crossing each other.\n",
      "        \n",
      "            Semantically, *where* is often used for *x1* > *x2* or similar.\n",
      "            By default, the nodes of the polygon defining the filled region\n",
      "            will only be placed at the positions in the *y* array.  Such a\n",
      "            polygon cannot describe the above semantics close to the\n",
      "            intersection.  The y-sections containing the intersecion are\n",
      "            simply clipped.\n",
      "        \n",
      "            Setting *interpolate* to *True* will calculate the actual\n",
      "            interscection 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",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            All other keyword arguments are passed on to `.PolyCollection`.\n",
      "            They control the `.Polygon` properties:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `.PolyCollection`\n",
      "            A `.PolyCollection` containing the plotted polygons.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fill_between : Fill between two sets of y-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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'where', 'x1', 'x2', 'y'.\n",
      "    \n",
      "    findobj(o=None, match=None, include_self=True)\n",
      "        Find artist objects.\n",
      "        \n",
      "        Recursively find all :class:`~matplotlib.artist.Artist` instances\n",
      "        contained in self.\n",
      "        \n",
      "        *match* can be\n",
      "        \n",
      "          - None: return all objects contained in artist.\n",
      "        \n",
      "          - function with signature ``boolean = match(artist)``\n",
      "            used to filter matches\n",
      "        \n",
      "          - class instance: e.g., Line2D.  Only return artists of class type.\n",
      "        \n",
      "        If *include_self* is True (default), include self in the list to be\n",
      "        checked for a match.\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 :class:`~matplotlib.axes.Axes` instance on the\n",
      "        current figure matching the given keyword args, or create one.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        To get the current polar axes on the current figure::\n",
      "        \n",
      "            plt.gca(projection='polar')\n",
      "        \n",
      "        If the current axes doesn't exist, or isn't a polar one, the appropriate\n",
      "        axes will be created and then returned.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.figure.Figure.gca : The figure's gca method.\n",
      "    \n",
      "    gcf()\n",
      "        Get a reference to the current figure.\n",
      "    \n",
      "    gci()\n",
      "        Get the current colorable artist.  Specifically, returns the\n",
      "        current :class:`~matplotlib.cm.ScalarMappable` instance (image or\n",
      "        patch collection), or *None* if no images or patch collections\n",
      "        have been defined.  The commands :func:`~matplotlib.pyplot.imshow`\n",
      "        and :func:`~matplotlib.pyplot.figimage` create\n",
      "        :class:`~matplotlib.image.Image` instances, and the commands\n",
      "        :func:`~matplotlib.pyplot.pcolor` and\n",
      "        :func:`~matplotlib.pyplot.scatter` create\n",
      "        :class:`~matplotlib.collections.Collection` instances.  The\n",
      "        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",
      "    get_current_fig_manager()\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",
      "    ginput(*args, **kwargs)\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",
      "        The buttons used for the various actions (adding points, removing\n",
      "        points, terminating the inputs) can be overridden via the\n",
      "        arguments *mouse_add*, *mouse_pop* and *mouse_stop*, that give\n",
      "        the associated mouse button: 1 for left, 2 for middle, 3 for\n",
      "        right.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int, optional, default: 1\n",
      "            Number of mouse clicks to accumulate. If negative, accumulate\n",
      "            clicks until the input is terminated manually.\n",
      "        timeout : scalar, optional, default: 30\n",
      "            Number of seconds to wait before timing out. If zero or negative\n",
      "            will never timeout.\n",
      "        show_clicks : bool, optional, default: False\n",
      "            If True, show a red cross at the location of each click.\n",
      "        mouse_add : int, one of (1, 2, 3), optional, default: 1 (left click)\n",
      "            Mouse button used to add points.\n",
      "        mouse_pop : int, one of (1, 2, 3), optional, default: 3 (right click)\n",
      "            Mouse button used to remove the most recently added point.\n",
      "        mouse_stop : int, one of (1, 2, 3), optional, default: 2 (middle click)\n",
      "            Mouse button used to stop input.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        points : 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",
      "        Turn the axes grids on or off.\n",
      "        \n",
      "        Set the axes grids on or off; *b* is a boolean.\n",
      "        \n",
      "        If *b* is *None* and ``len(kwargs)==0``, toggle the grid state.  If\n",
      "        *kwargs* are supplied, it is assumed that you want a grid and *b*\n",
      "        is thus set to *True*.\n",
      "        \n",
      "        *which* can be 'major' (default), 'minor', or 'both' to control\n",
      "        whether major tick grids, minor tick grids, or both are affected.\n",
      "        \n",
      "        *axis* can be 'both' (default), 'x', or 'y' to control which\n",
      "        set of gridlines are drawn.\n",
      "        \n",
      "        *kwargs* are used to set the grid line properties, e.g.,::\n",
      "        \n",
      "           ax.grid(color='r', linestyle='-', linewidth=2)\n",
      "        \n",
      "        Valid :class:`~matplotlib.lines.Line2D` kwargs are\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float\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 0x7f21cc139e18>, mincnt=None, marginals=False, hold=None, data=None, **kwargs)\n",
      "        Make a hexagonal binning plot.\n",
      "        \n",
      "        Make a hexagonal binning plot of *x* versus *y*, where *x*,\n",
      "        *y* are 1-D sequences of the same length, *N*. If *C* is *None*\n",
      "        (the default), this is a histogram of the number of occurrences\n",
      "        of the observations at (x[i],y[i]).\n",
      "        \n",
      "        If *C* is specified, it specifies values at the coordinate\n",
      "        (x[i],y[i]). These values are accumulated for each hexagonal\n",
      "        bin and then reduced according to *reduce_C_function*, which\n",
      "        defaults to numpy's mean function (np.mean). (If *C* is\n",
      "        specified, it must also be a 1-D sequence of the same length\n",
      "        as *x* and *y*.)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array or masked array\n",
      "        \n",
      "        C : array or masked array, optional, default is *None*\n",
      "        \n",
      "        gridsize : int or (int, int), optional, default is 100\n",
      "            The number of hexagons in the *x*-direction, default is\n",
      "            100. The corresponding number of hexagons in the\n",
      "            *y*-direction is chosen such that the hexagons are\n",
      "            approximately regular. Alternatively, gridsize can be a\n",
      "            tuple with two elements specifying the number of hexagons\n",
      "            in the *x*-direction and the *y*-direction.\n",
      "        \n",
      "        bins : {'log'} or int or sequence, optional, default is *None*\n",
      "            If *None*, no binning is applied; the color of each hexagon\n",
      "            directly corresponds to its count value.\n",
      "        \n",
      "            If 'log', use a logarithmic scale for the color\n",
      "            map. Internally, :math:`log_{10}(i+1)` is used to\n",
      "            determine the hexagon color.\n",
      "        \n",
      "            If an integer, divide the counts in the specified number\n",
      "            of bins, and color the hexagons accordingly.\n",
      "        \n",
      "            If a sequence of values, the values of the lower bound of\n",
      "            the bins to be used.\n",
      "        \n",
      "        xscale : {'linear', 'log'}, optional, default is 'linear'\n",
      "            Use a linear or log10 scale on the horizontal axis.\n",
      "        \n",
      "        yscale : {'linear', 'log'}, optional, default is 'linear'\n",
      "            Use a linear or log10 scale on the vertical axis.\n",
      "        \n",
      "        mincnt : int > 0, optional, default is *None*\n",
      "            If not *None*, only display cells with more than *mincnt*\n",
      "            number of points in the cell\n",
      "        \n",
      "        marginals : bool, optional, default is *False*\n",
      "            if marginals is *True*, plot the marginal density as\n",
      "            colormapped rectagles along the bottom of the x-axis and\n",
      "            left of the y-axis\n",
      "        \n",
      "        extent : scalar, optional, default is *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",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : object, optional, default is *None*\n",
      "            a :class:`matplotlib.colors.Colormap` instance. If *None*,\n",
      "            defaults to rc ``image.cmap``.\n",
      "        \n",
      "        norm : object, optional, default is *None*\n",
      "            :class:`matplotlib.colors.Normalize` instance is used to\n",
      "            scale luminance data to 0,1.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default is *None*\n",
      "            *vmin* and *vmax* are used in conjunction with *norm* to\n",
      "            normalize luminance data. If *None*, the min and max of the\n",
      "            color array *C* are used.  Note if you pass a norm instance\n",
      "            your settings for *vmin* and *vmax* will be ignored.\n",
      "        \n",
      "        alpha : scalar between 0 and 1, optional, default is *None*\n",
      "            the alpha value for the patches\n",
      "        \n",
      "        linewidths : scalar, optional, default is *None*\n",
      "            If *None*, defaults to 1.0.\n",
      "        \n",
      "        edgecolors : {'face', 'none', *None*} or color, optional\n",
      "        \n",
      "            If 'face' (the default), draws the edges in the same color as the\n",
      "            fill color.\n",
      "        \n",
      "            If 'none', no edge is drawn; this can sometimes lead to unsightly\n",
      "            unpainted pixels between the hexagons.\n",
      "        \n",
      "            If *None*, draws outlines in the default color.\n",
      "        \n",
      "            If a matplotlib color arg, draws outlines in the specified color.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        object\n",
      "            a :class:`~matplotlib.collections.PolyCollection` instance; use\n",
      "            :meth:`~matplotlib.collections.PolyCollection.get_array` on\n",
      "            this :class:`~matplotlib.collections.PolyCollection` to get\n",
      "            the counts in each hexagon.\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",
      "        Notes\n",
      "        -----\n",
      "        The standard descriptions of all the\n",
      "        :class:`~matplotlib.collections.Collection` parameters:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    hist(x, bins=None, range=None, density=None, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, normed=None, hold=None, data=None, **kwargs)\n",
      "        Plot a histogram.\n",
      "        \n",
      "        Compute and draw the histogram of *x*. The return value is a\n",
      "        tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,\n",
      "        [*patches0*, *patches1*,...]) if the input contains multiple\n",
      "        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 2-D 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 at present.\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 : integer or sequence or 'auto', optional\n",
      "            If an integer is given, ``bins + 1`` bin edges are calculated and\n",
      "            returned, consistent with :func:`numpy.histogram`.\n",
      "        \n",
      "            If `bins` is a sequence, gives bin edges, including left edge of\n",
      "            first bin and right edge of last bin.  In this case, `bins` is\n",
      "            returned unmodified.\n",
      "        \n",
      "            All but the last (righthand-most) bin is half-open.  In other\n",
      "            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",
      "            Unequally spaced bins are supported if *bins* is a sequence.\n",
      "        \n",
      "            If Numpy 1.11 is installed, may also be ``'auto'``.\n",
      "        \n",
      "            Default is taken from the rcParam ``hist.bins``.\n",
      "        \n",
      "        range : tuple or None, optional\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",
      "            Default is ``None``\n",
      "        \n",
      "        density : boolean, optional\n",
      "            If ``True``, the first element of the return tuple will\n",
      "            be the counts normalized to form a probability density, i.e.,\n",
      "            the area (or integral) under the histogram will sum to 1.\n",
      "            This is achieved by dividing the count by the number of\n",
      "            observations times the bin width and not dividing by the total\n",
      "            number of observations. If *stacked* is also ``True``, the sum of\n",
      "            the histograms is normalized to 1.\n",
      "        \n",
      "            Default is ``None`` for both *normed* and *density*. If either is\n",
      "            set, then that value will be used. If neither are set, then the\n",
      "            args will be treated as ``False``.\n",
      "        \n",
      "            If both *density* and *normed* are set an error is raised.\n",
      "        \n",
      "        weights : (n, ) array_like or None, optional\n",
      "            An array of weights, of the same shape as *x*.  Each value in *x*\n",
      "            only contributes its associated weight towards the bin count\n",
      "            (instead of 1).  If *normed* or *density* is ``True``,\n",
      "            the weights are normalized, so that the integral of the density\n",
      "            over the range remains 1.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        cumulative : boolean, optional\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. If *normed* or *density*\n",
      "            is also ``True`` then the histogram is normalized such that the\n",
      "            last bin equals 1. If *cumulative* evaluates to less than 0\n",
      "            (e.g., -1), the direction of accumulation is reversed.\n",
      "            In this case, if *normed* and/or *density* is also ``True``, then\n",
      "            the histogram is normalized such that the first bin equals 1.\n",
      "        \n",
      "            Default is ``False``\n",
      "        \n",
      "        bottom : array_like, scalar, or None\n",
      "            Location of the bottom baseline of each bin.  If a scalar,\n",
      "            the base line for each bin is shifted by the same amount.\n",
      "            If an array, each bin is shifted independently and the length\n",
      "            of bottom must match the number of bins.  If None, defaults to 0.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        histtype : {'bar', 'barstacked', 'step',  'stepfilled'}, optional\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",
      "        \n",
      "            - 'barstacked' is a bar-type histogram where multiple\n",
      "              data are stacked on top of each other.\n",
      "        \n",
      "            - 'step' generates a lineplot that is by default\n",
      "              unfilled.\n",
      "        \n",
      "            - 'stepfilled' generates a lineplot that is by default\n",
      "              filled.\n",
      "        \n",
      "            Default is 'bar'\n",
      "        \n",
      "        align : {'left', 'mid', 'right'}, optional\n",
      "            Controls how the histogram is plotted.\n",
      "        \n",
      "                - 'left': bars are centered on the left bin edges.\n",
      "        \n",
      "                - 'mid': bars are centered between the bin edges.\n",
      "        \n",
      "                - 'right': bars are centered on the right bin edges.\n",
      "        \n",
      "            Default is 'mid'\n",
      "        \n",
      "        orientation : {'horizontal', 'vertical'}, optional\n",
      "            If 'horizontal', `~matplotlib.pyplot.barh` will be used for\n",
      "            bar-type histograms and the *bottom* kwarg will be the left edges.\n",
      "        \n",
      "        rwidth : scalar or None, optional\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",
      "            Default is ``None``\n",
      "        \n",
      "        log : boolean, optional\n",
      "            If ``True``, the histogram axis will be set to a log scale. If\n",
      "            *log* is ``True`` and *x* is a 1D array, empty bins will be\n",
      "            filtered out and only the non-empty ``(n, bins, patches)``\n",
      "            will be returned.\n",
      "        \n",
      "            Default is ``False``\n",
      "        \n",
      "        color : color or array_like of colors or None, optional\n",
      "            Color spec or sequence of color specs, one per dataset.  Default\n",
      "            (``None``) uses the standard line color sequence.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        label : string or None, optional\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 the legend command will work as expected.\n",
      "        \n",
      "            default is ``None``\n",
      "        \n",
      "        stacked : boolean, optional\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",
      "            Default is ``False``\n",
      "        \n",
      "        normed : bool, optional\n",
      "            Deprecated; use the density keyword argument instead.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        n : array or list of arrays\n",
      "            The values of the histogram bins. See *normed* or *density*\n",
      "            and *weights* for a description of the possible semantics.\n",
      "            If input *x* is an array, then this is an array of length\n",
      "            *nbins*. If input is a sequence arrays\n",
      "            ``[data1, data2,..]``, then this is a list of arrays with\n",
      "            the values of the histograms for each of the arrays in the\n",
      "            same order.\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 : list or list of lists\n",
      "            Silent list of individual patches used to create the histogram\n",
      "            or list of such list if multiple input datasets.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Patch` properties\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        hist2d : 2D histograms\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'weights', 'x'.\n",
      "    \n",
      "    hist2d(x, y, bins=10, range=None, normed=False, weights=None, cmin=None, cmax=None, hold=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 | int | [int, int] | array_like | [array, array]]\n",
      "        \n",
      "            The bin specification:\n",
      "        \n",
      "                - If int, the number of bins for the two dimensions\n",
      "                  (nx=ny=bins).\n",
      "        \n",
      "                - If [int, int], the number of bins in each dimension\n",
      "                  (nx, ny = bins).\n",
      "        \n",
      "                - If array_like, the bin edges for the two dimensions\n",
      "                  (x_edges=y_edges=bins).\n",
      "        \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, default: None\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",
      "        normed : boolean, optional, default: False\n",
      "             Normalize histogram.\n",
      "        \n",
      "        weights : array_like, shape (n, ), optional, default: None\n",
      "            An array of values w_i weighing each sample (x_i, y_i).\n",
      "        \n",
      "        cmin : scalar, optional, default: None\n",
      "             All bins that has count less than cmin will not be displayed and\n",
      "             these count values in the return value count histogram will also\n",
      "             be set to nan upon return\n",
      "        \n",
      "        cmax : scalar, optional, default: None\n",
      "             All bins that has count more than cmax will not be displayed (set\n",
      "             to none before passing to imshow) and these count values in the\n",
      "             return value count histogram will also be set 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 : AxesImage\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : {Colormap, string}, optional\n",
      "            A :class:`matplotlib.colors.Colormap` instance.  If not set, use rc\n",
      "            settings.\n",
      "        \n",
      "        norm : Normalize, optional\n",
      "            A :class:`matplotlib.colors.Normalize` instance is used to\n",
      "            scale luminance data to ``[0, 1]``. If not set, defaults to\n",
      "            ``Normalize()``.\n",
      "        \n",
      "        vmin/vmax : {None, scalar}, optional\n",
      "            Arguments passed to the `Normalize` instance.\n",
      "        \n",
      "        alpha : ``0 <= scalar <= 1`` or ``None``, optional\n",
      "            The alpha blending value.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        hist : 1D histogram\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Rendering the histogram with a logarithmic color scale is\n",
      "        accomplished by passing a :class:`colors.LogNorm` instance to\n",
      "        the *norm* keyword argument. Likewise, power-law normalization\n",
      "        (similar in effect to gamma correction) can be accomplished with\n",
      "        :class:`colors.PowerNorm`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'weights', 'x', 'y'.\n",
      "    \n",
      "    hlines(y, xmin, xmax, colors='k', linestyles='solid', label='', hold=None, data=None, **kwargs)\n",
      "        Plot horizontal lines at each *y* from *xmin* to *xmax*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : scalar or sequence of scalar\n",
      "            y-indexes where to plot the lines.\n",
      "        \n",
      "        xmin, xmax : scalar or 1D array_like\n",
      "            Respective beginning and end of each line. If scalars are\n",
      "            provided, all lines will have same length.\n",
      "        \n",
      "        colors : array_like of colors, optional, default: 'k'\n",
      "        \n",
      "        linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional\n",
      "        \n",
      "        label : string, optional, default: ''\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : `~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",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'xmax', 'xmin', 'y'.\n",
      "    \n",
      "    hold(b=None)\n",
      "        .. deprecated:: 2.0\n",
      "            pyplot.hold is deprecated.\n",
      "            Future behavior will be consistent with the long-time default:\n",
      "            plot commands add elements without first clearing the\n",
      "            Axes and/or Figure.\n",
      "        \n",
      "        Set the hold state.  If *b* is None (default), toggle the\n",
      "        hold state, else set the hold state to boolean value *b*::\n",
      "        \n",
      "          hold()      # toggle hold\n",
      "          hold(True)  # hold is on\n",
      "          hold(False) # hold is off\n",
      "        \n",
      "        When *hold* is *True*, subsequent plot commands will add elements to\n",
      "        the current axes.  When *hold* is *False*, the current axes and\n",
      "        figure will be cleared on the next plot command.\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(*args, **kwargs)\n",
      "        Read an image from a file into an array.\n",
      "        \n",
      "        *fname* may be a string path, a valid URL, or a Python\n",
      "        file-like object.  If using a file object, it must be opened in binary\n",
      "        mode.\n",
      "        \n",
      "        If *format* is provided, will try to read file of that type,\n",
      "        otherwise the format is deduced from the filename.  If nothing can\n",
      "        be deduced, PNG is tried.\n",
      "        \n",
      "        Return value is a :class:`numpy.array`.  For grayscale images, the\n",
      "        return array is MxN.  For RGB images, the return value is MxNx3.\n",
      "        For RGBA images the return value is MxNx4.\n",
      "        \n",
      "        matplotlib can only read PNGs natively, but if `PIL\n",
      "        <http://www.pythonware.com/products/pil/>`_ is installed, it will\n",
      "        use it to load the image and return an array (if possible) which\n",
      "        can be used with :func:`~matplotlib.pyplot.imshow`. Note, URL strings\n",
      "        may not be compatible with PIL. Check the PIL documentation for more\n",
      "        information.\n",
      "    \n",
      "    imsave(*args, **kwargs)\n",
      "        Save an array as in image file.\n",
      "        \n",
      "        The output formats available depend on the backend being used.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fname : str or file-like\n",
      "            Path string to a filename, or a Python file-like object.\n",
      "            If *format* is *None* and *fname* is a string, the output\n",
      "            format is deduced from the extension of the filename.\n",
      "        arr : array-like\n",
      "            An MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA) array.\n",
      "        vmin, vmax: [ None | scalar ]\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 : matplotlib.colors.Colormap, optional\n",
      "            For example, ``cm.viridis``.  If ``None``, defaults to the\n",
      "            ``image.cmap`` rcParam.\n",
      "        format : str\n",
      "            One of the file extensions supported by the active backend.  Most\n",
      "            backends support png, pdf, ps, eps and svg.\n",
      "        origin : [ 'upper' | 'lower' ]\n",
      "            Indicates whether the ``(0, 0)`` index of the array is in the\n",
      "            upper left or lower left corner of the axes.  Defaults to the\n",
      "            ``image.origin`` rcParam.\n",
      "        dpi : int\n",
      "            The DPI to store in the metadata of the file.  This does not affect the\n",
      "            resolution of the output image.\n",
      "    \n",
      "    imshow(X, cmap=None, norm=None, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, shape=None, filternorm=1, filterrad=4.0, imlim=None, resample=None, url=None, hold=None, data=None, **kwargs)\n",
      "        Display an image on the axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X : array_like, shape (n, m) or (n, m, 3) or (n, m, 4)\n",
      "            Display the image in `X` to current axes.  `X` may be an\n",
      "            array or a PIL image. If `X` is an array, it\n",
      "            can have the following shapes and types:\n",
      "        \n",
      "            - MxN -- values to be mapped (float or int)\n",
      "            - MxNx3 -- RGB (float or uint8)\n",
      "            - MxNx4 -- RGBA (float or uint8)\n",
      "        \n",
      "            MxN arrays are mapped to colors based on the `norm` (mapping\n",
      "            scalar to scalar) and the `cmap` (mapping the normed scalar to\n",
      "            a color).\n",
      "        \n",
      "            Elements of RGB and RGBA arrays represent pixels of an MxN image.\n",
      "            All values should be in the range [0 .. 1] for floats or\n",
      "            [0 .. 255] for integers.  Out-of-range values will be clipped to\n",
      "            these bounds.\n",
      "        \n",
      "        cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "            If None, default to rc `image.cmap` value. `cmap` is ignored\n",
      "            if `X` is 3-D, directly specifying RGB(A) values.\n",
      "        \n",
      "        aspect : ['auto' | 'equal' | scalar], optional, default: None\n",
      "            If 'auto', changes the image aspect ratio to match that of the\n",
      "            axes.\n",
      "        \n",
      "            If 'equal', and `extent` is None, changes the axes aspect ratio to\n",
      "            match that of the image. If `extent` is not `None`, the axes\n",
      "            aspect ratio is changed to match that of the extent.\n",
      "        \n",
      "            If None, default to rc ``image.aspect`` value.\n",
      "        \n",
      "        interpolation : string, optional, default: None\n",
      "            Acceptable values are 'none', 'nearest', 'bilinear', 'bicubic',\n",
      "            'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',\n",
      "            'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc',\n",
      "            'lanczos'\n",
      "        \n",
      "            If `interpolation` is None, default to rc `image.interpolation`.\n",
      "            See also the `filternorm` and `filterrad` parameters.\n",
      "            If `interpolation` is 'none', then no interpolation is performed\n",
      "            on the Agg, ps and pdf backends. Other backends will fall back to\n",
      "            'nearest'.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional, default: None\n",
      "            A `~matplotlib.colors.Normalize` instance is used to scale\n",
      "            a 2-D float `X` input to the (0, 1) range for input to the\n",
      "            `cmap`. If `norm` is None, use the default func:`normalize`.\n",
      "            If `norm` is an instance of `~matplotlib.colors.NoNorm`,\n",
      "            `X` must be an array of integers that index directly into\n",
      "            the lookup table of the `cmap`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default: None\n",
      "            `vmin` and `vmax` are used in conjunction with norm to normalize\n",
      "            luminance data.  Note if you pass a `norm` instance, your\n",
      "            settings for `vmin` and `vmax` will be ignored.\n",
      "        \n",
      "        alpha : scalar, optional, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "            The ``alpha`` argument is ignored for RGBA input data.\n",
      "        \n",
      "        origin : ['upper' | 'lower'], optional, default: None\n",
      "            Place the [0,0] index of the array in the upper left or lower left\n",
      "            corner of the axes. If None, default to rc `image.origin`.\n",
      "        \n",
      "        extent : scalars (left, right, bottom, top), optional, default: None\n",
      "            The location, in data-coordinates, of the lower-left and\n",
      "            upper-right corners. If `None`, the image is positioned such that\n",
      "            the pixel centers fall on zero-based (row, column) indices.\n",
      "        \n",
      "        shape : scalars (columns, rows), optional, default: None\n",
      "            For raw buffer images\n",
      "        \n",
      "        filternorm : scalar, optional, default: 1\n",
      "            A parameter for the antigrain image resize filter.  From the\n",
      "            antigrain documentation, if `filternorm` = 1, 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 : scalar, optional, 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",
      "        Returns\n",
      "        -------\n",
      "        image : `~matplotlib.image.AxesImage`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.artist.Artist` properties.\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",
      "        Two typical representations are used 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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\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 with IPython terminals and kernels,\n",
      "        as well as vanilla python shells.\n",
      "    \n",
      "    ioff()\n",
      "        Turn interactive mode off.\n",
      "    \n",
      "    ion()\n",
      "        Turn interactive mode on.\n",
      "    \n",
      "    ishold()\n",
      "        .. deprecated:: 2.0\n",
      "            pyplot.hold is deprecated.\n",
      "            Future behavior will be consistent with the long-time default:\n",
      "            plot commands add elements without first clearing the\n",
      "            Axes and/or Figure.\n",
      "        \n",
      "        Return the hold status of the current axes.\n",
      "    \n",
      "    isinteractive()\n",
      "        Return status of interactive mode.\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",
      "        Places 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 three different ways how 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",
      "            line, = ax.plot([1, 2, 3], label='Inline label')\n",
      "            ax.legend()\n",
      "        \n",
      "        or::\n",
      "        \n",
      "            line.set_label('Label via method')\n",
      "            line, = ax.plot([1, 2, 3])\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 way of using 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",
      "            legend((line1, line2, line3), ('label1', 'label2', 'label3'))\n",
      "        \n",
      "        Parameters\n",
      "        ----------\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 : sequence of strings, 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",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        loc : int or string or pair of floats, default: 'upper right'\n",
      "            The location of the legend. Possible codes are:\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",
      "        \n",
      "            Alternatively can be a 2-tuple giving ``x, y`` of the lower-left\n",
      "            corner of the legend in axes coordinates (in which case\n",
      "            ``bbox_to_anchor`` will be ignored).\n",
      "        \n",
      "        bbox_to_anchor : `.BboxBase` or pair of floats\n",
      "            Specify any arbitrary location for the legend in `bbox_transform`\n",
      "            coordinates (default Axes coordinates).\n",
      "        \n",
      "            For example, to put the legend's upper right hand corner in the\n",
      "            center of the axes the following keywords can be used::\n",
      "        \n",
      "               loc='upper right', bbox_to_anchor=(0.5, 0.5)\n",
      "        \n",
      "        ncol : integer\n",
      "            The number of columns that the legend has. Default is 1.\n",
      "        \n",
      "        prop : None or :class:`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 float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "            Controls the font size of the legend. If the value is numeric the\n",
      "            size will be the absolute font size in points. String values are\n",
      "            relative to the current default font size. This argument is only\n",
      "            used if `prop` is not specified.\n",
      "        \n",
      "        numpoints : None or int\n",
      "            The number of marker points in the legend when creating a legend\n",
      "            entry for a `.Line2D` (line).\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.numpoints`.\n",
      "        \n",
      "        scatterpoints : None or int\n",
      "            The number of marker points in the legend when creating\n",
      "            a legend entry for a `.PathCollection` (scatter plot).\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.scatterpoints`.\n",
      "        \n",
      "        scatteryoffsets : iterable of floats\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]``. Default is ``[0.375, 0.5, 0.3125]``.\n",
      "        \n",
      "        markerscale : None or int or float\n",
      "            The relative size of legend markers compared with the originally\n",
      "            drawn ones.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.markerscale`.\n",
      "        \n",
      "        markerfirst : bool\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\n",
      "            label.\n",
      "            Default is *True*.\n",
      "        \n",
      "        frameon : None or bool\n",
      "            Control whether the legend should be drawn on a patch\n",
      "            (frame).\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.frameon`.\n",
      "        \n",
      "        fancybox : None or bool\n",
      "            Control whether round edges should be enabled around the\n",
      "            :class:`~matplotlib.patches.FancyBboxPatch` which makes up the\n",
      "            legend's background.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.fancybox`.\n",
      "        \n",
      "        shadow : None or bool\n",
      "            Control whether to draw a shadow behind the legend.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.shadow`.\n",
      "        \n",
      "        framealpha : None or float\n",
      "            Control the alpha transparency of the legend's background.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.framealpha`.  If shadow is activated and\n",
      "            *framealpha* is ``None``, the default value is ignored.\n",
      "        \n",
      "        facecolor : None or \"inherit\" or a color spec\n",
      "            Control the legend's background color.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.facecolor`.  If ``\"inherit\"``, it will take\n",
      "            :rc:`axes.facecolor`.\n",
      "        \n",
      "        edgecolor : None or \"inherit\" or a color spec\n",
      "            Control the legend's background patch edge color.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.edgecolor` If ``\"inherit\"``, it will take\n",
      "            :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 :class:`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",
      "        borderpad : float or None\n",
      "            The fractional whitespace inside the legend border.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.borderpad`.\n",
      "        \n",
      "        labelspacing : float or None\n",
      "            The vertical space between the legend entries.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.labelspacing`.\n",
      "        \n",
      "        handlelength : float or None\n",
      "            The length of the legend handles.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.handlelength`.\n",
      "        \n",
      "        handletextpad : float or None\n",
      "            The pad between the legend handle and text.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.handletextpad`.\n",
      "        \n",
      "        borderaxespad : float or None\n",
      "            The pad between the axes and legend border.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.borderaxespad`.\n",
      "        \n",
      "        columnspacing : float or None\n",
      "            The spacing between columns.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None``, which will take the value from\n",
      "            :rc:`legend.columnspacing`.\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 :func:`matplotlib.legend.Legend.get_legend_handler_map`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        \n",
      "        :class:`matplotlib.legend.Legend` instance\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        Not all kinds of artist are supported by the legend command. See\n",
      "        :ref:`sphx_glr_tutorials_intermediate_legend_guide.py` for details.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        .. plot:: gallery/api/legend.py\n",
      "    \n",
      "    locator_params(axis='both', tight=None, **kwargs)\n",
      "        Control behavior of tick locators.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        axis : ['both' | 'x' | 'y'], optional\n",
      "            The axis on which to operate.\n",
      "        \n",
      "        tight : bool or None, optional\n",
      "            Parameter passed to :meth:`autoscale_view`.\n",
      "            Default is None, for no change.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kw :\n",
      "            Remaining keyword arguments are passed to directly to the\n",
      "            :meth:`~matplotlib.ticker.MaxNLocator.set_params` method.\n",
      "        \n",
      "        Typically one might want to reduce the maximum number\n",
      "        of ticks and use tight bounds when plotting small\n",
      "        subplots, for example::\n",
      "        \n",
      "            ax.locator_params(tight=True, nbins=4)\n",
      "        \n",
      "        Because the locator is involved in autoscaling,\n",
      "        :meth:`autoscale_view` is called automatically after\n",
      "        the parameters are changed.\n",
      "        \n",
      "        This presently works only for the\n",
      "        :class:`~matplotlib.ticker.MaxNLocator` used\n",
      "        by default on linear axes, but it may be generalized.\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 *basex/y*, *subsx/y* and *nonposx/y* control\n",
      "        the x/y-axis properties. They are just forwarded to `.Axes.set_xscale`\n",
      "        and `.Axes.set_yscale`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        basex, basey : scalar, optional, default 10\n",
      "            Base of the x/y logarithm.\n",
      "        \n",
      "        subsx, subsy : sequence, optional\n",
      "            The location of the minor x/y ticks. If *None*, reasonable\n",
      "            locations are automatically chosen depending on the number of\n",
      "            decades in the plot.\n",
      "            See `.Axes.set_xscale` / `.Axes.set_yscale` for details.\n",
      "        \n",
      "        nonposx, nonposy : {'mask', 'clip'}, optional, default 'mask'\n",
      "            Non-positive values in x or y can be masked as invalid, or clipped\n",
      "            to a very small positive number.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines\n",
      "            A list of `~.Line2D` 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, hold=None, data=None, **kwargs)\n",
      "        Plot the magnitude spectrum.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          magnitude_spectrum(x, Fs=2, Fc=0,  window=mlab.window_hanning,\n",
      "                             pad_to=None, sides='default', **kwargs)\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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  While not increasing the actual resolution of\n",
      "            the spectrum (the minimum distance between resolvable peaks),\n",
      "            this can give more points in the plot, allowing for more\n",
      "            detail. This corresponds to the *n* parameter in the call to fft().\n",
      "            The default is None, which sets *pad_to* equal to the length of the\n",
      "            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 : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            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 : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`psd`\n",
      "            :func:`psd` plots the power spectral density.`.\n",
      "        \n",
      "        :func:`angle_spectrum`\n",
      "            :func:`angle_spectrum` plots the angles of the corresponding\n",
      "            frequencies.\n",
      "        \n",
      "        :func:`phase_spectrum`\n",
      "            :func:`phase_spectrum` plots the phase (unwrapped angle) of the\n",
      "            corresponding frequencies.\n",
      "        \n",
      "        :func:`specgram`\n",
      "            :func:`specgram` can plot the magnitude spectrum of segments within\n",
      "            the signal in a colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    margins(*args, **kw)\n",
      "        Set or retrieve autoscaling margins.\n",
      "        \n",
      "        signatures::\n",
      "        \n",
      "            margins()\n",
      "        \n",
      "        returns xmargin, ymargin\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            margins(margin)\n",
      "        \n",
      "            margins(xmargin, ymargin)\n",
      "        \n",
      "            margins(x=xmargin, y=ymargin)\n",
      "        \n",
      "            margins(..., tight=False)\n",
      "        \n",
      "        All three forms above set the xmargin and ymargin parameters.\n",
      "        All keyword parameters are optional.  A single argument\n",
      "        specifies both xmargin and ymargin. The padding added to the end of\n",
      "        each interval is *margin* times the data interval. The *margin* must\n",
      "        be a float in the range [0, 1].\n",
      "        \n",
      "        The *tight* parameter is passed to :meth:`autoscale_view`\n",
      "        , which is executed after a margin is changed; the default here is\n",
      "        *True*, on the assumption that when margins are specified, no\n",
      "        additional padding to match tick marks is usually desired.  Setting\n",
      "        *tight* to *None* will preserve the previous setting.\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",
      "    matshow(A, fignum=None, **kw)\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",
      "        With the exception of *fignum*, keyword arguments are passed to\n",
      "        :func:`~matplotlib.pyplot.imshow`.  You may set the *origin*\n",
      "        kwarg to \"lower\" if you want the first row in the array to be\n",
      "        at the bottom instead of the top.\n",
      "        \n",
      "        \n",
      "        *fignum*: [ None | integer | False ]\n",
      "          By default, :func:`matshow` creates a new figure window with\n",
      "          automatic numbering.  If *fignum* is given as an integer, the\n",
      "          created figure will use this figure number.  Because of how\n",
      "          :func:`matshow` tries to set the figure aspect ratio to be the\n",
      "          one of the array, if you provide the number of an already\n",
      "          existing figure, strange things may happen.\n",
      "        \n",
      "          If *fignum* is *False* or 0, a new figure window will **NOT** be created.\n",
      "    \n",
      "    minorticks_off()\n",
      "        Remove minor ticks from the current plot.\n",
      "    \n",
      "    minorticks_on()\n",
      "        Display minor ticks on the current plot.\n",
      "        \n",
      "        Displaying minor ticks reduces performance; turn them off using\n",
      "        minorticks_off() if drawing speed is a problem.\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",
      "    over(func, *args, **kwargs)\n",
      "        .. deprecated:: 2.0\n",
      "            pyplot.hold is deprecated.\n",
      "            Future behavior will be consistent with the long-time default:\n",
      "            plot commands add elements without first clearing the\n",
      "            Axes and/or Figure.\n",
      "        \n",
      "        Call a function with hold(True).\n",
      "        \n",
      "        Calls::\n",
      "        \n",
      "          func(*args, **kwargs)\n",
      "        \n",
      "        with ``hold(True)`` and then restores the hold state.\n",
      "    \n",
      "    pause(interval)\n",
      "        Pause 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, see\n",
      "        :mod:`matplotlib.animation`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This function is experimental; its behavior may be changed or extended in a\n",
      "        future release.\n",
      "    \n",
      "    pcolor(*args, **kwargs)\n",
      "        Create a pseudocolor plot of a 2-D array.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            pcolor(C, **kwargs)\n",
      "            pcolor(X, Y, C, **kwargs)\n",
      "        \n",
      "        pcolor can be very slow for large arrays; consider\n",
      "        using the similar but much faster\n",
      "        :func:`~matplotlib.pyplot.pcolormesh` instead.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        C : array_like\n",
      "            An array of color values.\n",
      "        \n",
      "        X, Y : array_like, optional\n",
      "            If given, specify the (x, y) coordinates of the colored\n",
      "            quadrilaterals; the quadrilateral for ``C[i,j]`` has corners at::\n",
      "        \n",
      "                (X[i,   j],   Y[i,   j]),\n",
      "                (X[i,   j+1], Y[i,   j+1]),\n",
      "                (X[i+1, j],   Y[i+1, j]),\n",
      "                (X[i+1, j+1], Y[i+1, j+1])\n",
      "        \n",
      "            Ideally the dimensions of ``X`` and ``Y`` should be one greater\n",
      "            than those of ``C``; if the dimensions are the same, then the last\n",
      "            row and column of ``C`` will be ignored.\n",
      "        \n",
      "            Note that the column index corresponds to the\n",
      "            x-coordinate, and the row index corresponds to y; for\n",
      "            details, see the :ref:`Grid Orientation\n",
      "            <axes-pcolor-grid-orientation>` section below.\n",
      "        \n",
      "            If either or both of ``X`` and ``Y`` are 1-D arrays or column\n",
      "            vectors, they will be expanded as needed into the appropriate 2-D\n",
      "            arrays, making a rectangular grid.\n",
      "        \n",
      "        cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "            If `None`, default to rc settings.\n",
      "        \n",
      "        norm : `matplotlib.colors.Normalize`, optional, default: None\n",
      "            An instance is used to scale luminance data to (0, 1).\n",
      "            If `None`, defaults to :func:`normalize`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default: None\n",
      "            ``vmin`` and ``vmax`` are used in conjunction with ``norm`` to\n",
      "            normalize luminance data.  If either is `None`, it is autoscaled to\n",
      "            the respective min or max of the color array ``C``.  If not `None`,\n",
      "            ``vmin`` or ``vmax`` passed in here override any pre-existing\n",
      "            values supplied in the ``norm`` instance.\n",
      "        \n",
      "        edgecolors : {None, 'none', color, color sequence}\n",
      "            If None, the rc setting is used by default.\n",
      "            If 'none', edges will not be visible.\n",
      "            An mpl color or sequence of colors will set the edge color.\n",
      "        \n",
      "        alpha : scalar, optional, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        snap : bool, optional, default: False\n",
      "            Whether to snap the mesh to pixel boundaries.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        collection : `matplotlib.collections.Collection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        antialiaseds : bool, optional, 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`, which defaults to True.\n",
      "            Stroking the edges may be preferred if ``alpha`` is 1, but will\n",
      "            cause artifacts otherwise.\n",
      "        \n",
      "        **kwargs :\n",
      "        \n",
      "            Any unused keyword arguments are passed along to the\n",
      "            `~matplotlib.collections.PolyCollection` constructor:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[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",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. _axes-pcolor-grid-orientation:\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 [i, j], [i+1, j],\n",
      "        [i, j+1], [i+1, j+1]) is masked, nothing is plotted.\n",
      "        \n",
      "        The grid orientation follows the MATLAB convention: an array ``C`` with\n",
      "        shape (nrows, ncolumns) is plotted with the column number as ``X`` and\n",
      "        the row number as ``Y``, increasing up; hence it is plotted the way the\n",
      "        array would be printed, except that the ``Y`` axis is reversed. That\n",
      "        is, ``C`` is taken as ``C`` (y, x).\n",
      "        \n",
      "        Similarly for :func:`meshgrid`::\n",
      "        \n",
      "            x = np.arange(5)\n",
      "            y = np.arange(3)\n",
      "            X, Y = np.meshgrid(x, y)\n",
      "        \n",
      "        is equivalent to::\n",
      "        \n",
      "            X = array([[0, 1, 2, 3, 4],\n",
      "                       [0, 1, 2, 3, 4],\n",
      "                       [0, 1, 2, 3, 4]])\n",
      "        \n",
      "            Y = array([[0, 0, 0, 0, 0],\n",
      "                       [1, 1, 1, 1, 1],\n",
      "                       [2, 2, 2, 2, 2]])\n",
      "        \n",
      "        so if you have::\n",
      "        \n",
      "            C = rand(len(x), len(y))\n",
      "        \n",
      "        then you need to transpose C::\n",
      "        \n",
      "            pcolor(X, Y, C.T)\n",
      "        \n",
      "        or::\n",
      "        \n",
      "            pcolor(C.T)\n",
      "        \n",
      "        MATLAB :func:`pcolor` always discards the last row and column of ``C``,\n",
      "        but Matplotlib displays the last row and column if ``X`` and ``Y`` are\n",
      "        not specified, or if ``X`` and ``Y`` have one more row and column than\n",
      "        ``C``.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    pcolormesh(*args, **kwargs)\n",
      "        Plot a quadrilateral mesh.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          pcolormesh(C)\n",
      "          pcolormesh(X, Y, C)\n",
      "          pcolormesh(C, **kwargs)\n",
      "        \n",
      "        Create a pseudocolor plot of a 2-D array.\n",
      "        \n",
      "        pcolormesh is similar to :func:`~matplotlib.pyplot.pcolor`,\n",
      "        but uses a different mechanism and returns a different\n",
      "        object; pcolor returns a\n",
      "        :class:`~matplotlib.collections.PolyCollection` but pcolormesh\n",
      "        returns a\n",
      "        :class:`~matplotlib.collections.QuadMesh`.  It is much faster,\n",
      "        so it is almost always preferred for large arrays.\n",
      "        \n",
      "        *C* may be a masked array, but *X* and *Y* may not.  Masked\n",
      "        array support is implemented via *cmap* and *norm*; in\n",
      "        contrast, :func:`~matplotlib.pyplot.pcolor` simply does not\n",
      "        draw quadrilaterals with masked colors or vertices.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : Colormap, optional\n",
      "            A :class:`matplotlib.colors.Colormap` instance. If ``None``, use\n",
      "            rc settings.\n",
      "        \n",
      "        norm : Normalize, optional\n",
      "            A :class:`matplotlib.colors.Normalize` instance is used to\n",
      "            scale luminance data to 0,1. If ``None``, defaults to\n",
      "            :func:`normalize`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional\n",
      "            *vmin* and *vmax* are used in conjunction with *norm* to\n",
      "            normalize luminance data. If either is ``None``, it is autoscaled\n",
      "            to the respective min or max of the color array *C*.\n",
      "            If not ``None``, *vmin* or *vmax* passed in here override any\n",
      "            pre-existing values supplied in the *norm* instance.\n",
      "        \n",
      "        shading : [ 'flat' | 'gouraud' ], optional\n",
      "            'flat' indicates a solid color for each quad. When\n",
      "            'gouraud', each quad will be Gouraud shaded. When gouraud\n",
      "            shading, *edgecolors* is ignored.\n",
      "        \n",
      "        edgecolors : string, color, color sequence, optional\n",
      "            - If ``None``, the rc setting is used by default.\n",
      "            - If ``'None'``, edges will not be visible.\n",
      "            - If ``'face'``, edges will have the same color as the faces.\n",
      "        \n",
      "            An mpl color or sequence of colors will also set the edge color.\n",
      "        \n",
      "        alpha : scalar, optional\n",
      "            Alpha blending value. Must be between 0 and 1.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        matplotlib.collections.QuadMesh\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.pyplot.pcolor :\n",
      "            For an explanation of the grid orientation\n",
      "            (:ref:`Grid Orientation <axes-pcolor-grid-orientation>`)\n",
      "            and the expansion of 1-D *X* and/or *Y* to 2-D arrays.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        kwargs can be used to control the\n",
      "        :class:`matplotlib.collections.QuadMesh` properties:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    phase_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, hold=None, data=None, **kwargs)\n",
      "        Plot the phase spectrum.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          phase_spectrum(x, Fs=2, Fc=0,  window=mlab.window_hanning,\n",
      "                         pad_to=None, sides='default', **kwargs)\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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  While not increasing the actual resolution of\n",
      "            the spectrum (the minimum distance between resolvable peaks),\n",
      "            this can give more points in the plot, allowing for more\n",
      "            detail. This corresponds to the *n* parameter in the call to fft().\n",
      "            The default is None, which sets *pad_to* equal to the length of the\n",
      "            input signal (i.e. no padding).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            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 : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`magnitude_spectrum`\n",
      "            :func:`magnitude_spectrum` plots the magnitudes of the\n",
      "            corresponding frequencies.\n",
      "        \n",
      "        :func:`angle_spectrum`\n",
      "            :func:`angle_spectrum` plots the wrapped version of this function.\n",
      "        \n",
      "        :func:`specgram`\n",
      "            :func:`specgram` can plot the phase spectrum of segments within the\n",
      "            signal in a colormap.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None, radius=None, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, hold=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 : array-like\n",
      "            The wedge sizes.\n",
      "        \n",
      "        explode : array-like, optional, 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, optional, default: None\n",
      "            A sequence of strings providing the labels for each wedge\n",
      "        \n",
      "        colors : array-like, optional, default: None\n",
      "            A sequence of matplotlib color args through which the pie chart\n",
      "            will cycle.  If *None*, will use the colors in the currently\n",
      "            active cycle.\n",
      "        \n",
      "        autopct : None (default), string, or function, optional\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, optional, 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, optional, default: False\n",
      "            Draw a shadow beneath the pie.\n",
      "        \n",
      "        labeldistance : float, optional, default: 1.1\n",
      "            The radial distance at which the pie labels are drawn\n",
      "        \n",
      "        startangle : float, optional, default: None\n",
      "            If not *None*, rotates the start of the pie chart by *angle*\n",
      "            degrees counterclockwise from the x-axis.\n",
      "        \n",
      "        radius : float, optional, default: None\n",
      "            The radius of the pie, if *radius* is *None* it will be set to 1.\n",
      "        \n",
      "        counterclock : bool, optional, default: True\n",
      "            Specify fractions direction, clockwise or counterclockwise.\n",
      "        \n",
      "        wedgeprops : dict, optional, 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, optional, default: None\n",
      "            Dict of arguments to pass to the text objects.\n",
      "        \n",
      "        center :  list of float, optional, default: (0, 0)\n",
      "            Center position of the chart. Takes value (0, 0) or is a sequence\n",
      "            of 2 scalars.\n",
      "        \n",
      "        frame : bool, optional, default: False\n",
      "            Plot axes frame with the chart if true.\n",
      "        \n",
      "        rotatelabels : bool, optional, 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 :class:`matplotlib.patches.Wedge` instances\n",
      "        \n",
      "        texts : list\n",
      "            A list of the label :class:`matplotlib.text.Text` instances.\n",
      "        \n",
      "        autotexts : list\n",
      "            A list of :class:`~matplotlib.text.Text` instances for the numeric\n",
      "            labels. This will only be returned if the parameter *autopct* is\n",
      "            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",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'explode', 'labels', 'x'.\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, **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",
      "        **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.DataFame` 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",
      "        - Alternatively, if your data is already a 2d array, you can pass it\n",
      "          directly to *x*, *y*. A separate data set will be drawn for every\n",
      "          column.\n",
      "        \n",
      "          Example: an array ``a`` where the first column represents the *x*\n",
      "          values and the other columns are the *y* columns::\n",
      "        \n",
      "          >>> plot(a[0], a[1:])\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 the\n",
      "        'axes.prop_cycle' rcParam.\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. If not given, they default to\n",
      "            ``[0, ..., N-1]``.\n",
      "        \n",
      "            Commonly, these parameters are arrays of length N. However,\n",
      "            scalars are supported as well (equivalent to an array with\n",
      "            constant value).\n",
      "        \n",
      "            The parameters can also be 2-dimensional. Then, the columns\n",
      "            represent separate data sets.\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",
      "        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",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        scalex, scaley : bool, optional, default: True\n",
      "            These parameters determined if the view limits are adapted to\n",
      "            the 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 make multiple lines with one plot command, the kwargs\n",
      "            apply to all those lines.\n",
      "        \n",
      "            Here is a list of available `.Line2D` properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines\n",
      "            A list of `.Line2D` objects representing the plotted data.\n",
      "        \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scatter : XY scatter plot with markers of variing size and/or color (\n",
      "            sometimes also called bubble chart).\n",
      "        \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        **Format Strings**\n",
      "        \n",
      "        A format string consists of a part for color, marker and line::\n",
      "        \n",
      "            fmt = '[color][marker][line]'\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",
      "        **Colors**\n",
      "        \n",
      "        The following color abbreviations are supported:\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",
      "        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",
      "        **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",
      "        ``'s'``          square marker\n",
      "        ``'p'``          pentagon marker\n",
      "        ``'*'``          star marker\n",
      "        ``'h'``          hexagon1 marker\n",
      "        ``'H'``          hexagon2 marker\n",
      "        ``'+'``          plus marker\n",
      "        ``'x'``          x 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",
      "            'ro'   # 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",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    plot_date(x, y, fmt='o', tz=None, xdate=True, ydate=False, hold=None, data=None, **kwargs)\n",
      "        Plot data that contains 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*.\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 : [ *None* | timezone string | :class:`tzinfo` instance]\n",
      "            The time zone to use in labeling dates. If *None*, defaults to\n",
      "            rcParam ``timezone``.\n",
      "        \n",
      "        xdate : bool, optional, default: True\n",
      "            If *True*, the *x*-axis will be interpreted as Matplotlib dates.\n",
      "        \n",
      "        ydate : bool, optional, default: False\n",
      "            If *True*, the *y*-axis will be interpreted as Matplotlib dates.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines\n",
      "            A list of `~.Line2D` objects representing the plotted data.\n",
      "        \n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \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",
      "        \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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    plotfile(fname, cols=(0,), plotfuncs=None, comments='#', skiprows=0, checkrows=5, delimiter=',', names=None, subplots=True, newfig=True, **kwargs)\n",
      "        Plot the data in a file.\n",
      "        \n",
      "        *cols* is a sequence of column identifiers to plot.  An identifier\n",
      "        is either an int or a string.  If it is an int, it indicates the\n",
      "        column number.  If it is a string, it indicates the column header.\n",
      "        matplotlib will make column headers lower case, replace spaces with\n",
      "        underscores, and remove all illegal characters; so ``'Adj Close*'``\n",
      "        will have name ``'adj_close'``.\n",
      "        \n",
      "        - If len(*cols*) == 1, only that column will be plotted on the *y* axis.\n",
      "        \n",
      "        - If len(*cols*) > 1, the first element will be an identifier for\n",
      "          data for the *x* axis and the remaining elements will be the\n",
      "          column indexes for multiple subplots if *subplots* is *True*\n",
      "          (the default), or for lines in a single subplot if *subplots*\n",
      "          is *False*.\n",
      "        \n",
      "        *plotfuncs*, if not *None*, is a dictionary mapping identifier to\n",
      "        an :class:`~matplotlib.axes.Axes` plotting function as a string.\n",
      "        Default is 'plot', other choices are 'semilogy', 'fill', 'bar',\n",
      "        etc.  You must use the same type of identifier in the *cols*\n",
      "        vector as you use in the *plotfuncs* dictionary, e.g., integer\n",
      "        column numbers in both or column names in both. If *subplots*\n",
      "        is *False*, then including any function such as 'semilogy'\n",
      "        that changes the axis scaling will set the scaling for all\n",
      "        columns.\n",
      "        \n",
      "        *comments*, *skiprows*, *checkrows*, *delimiter*, and *names*\n",
      "        are all passed on to :func:`matplotlib.pylab.csv2rec` to\n",
      "        load the data into a record array.\n",
      "        \n",
      "        If *newfig* is *True*, the plot always will be made in a new figure;\n",
      "        if *False*, it will be made in the current figure if one exists,\n",
      "        else in a new figure.\n",
      "        \n",
      "        kwargs are passed on to plotting functions.\n",
      "        \n",
      "        Example usage::\n",
      "        \n",
      "          # plot the 2nd and 4th column against the 1st in two subplots\n",
      "          plotfile(fname, (0,1,3))\n",
      "        \n",
      "          # plot using column names; specify an alternate plot type for volume\n",
      "          plotfile(fname, ('date', 'volume', 'adj_close'),\n",
      "                                        plotfuncs={'volume': 'semilogy'})\n",
      "        \n",
      "        Note: plotfile is intended as a convenience for quickly plotting\n",
      "        data from flat files; it is not intended as an alternative\n",
      "        interface to general plotting with pyplot or matplotlib.\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 ``s``.                                                                                                                                            \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 axis.                                                                                                                                    \n",
      "        `axis`                       Convenience method to get or set axis properties.                                                                                                                                     \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",
      "        `barbs`                      Plot a 2-D field of barbs.                                                                                                                                                            \n",
      "        `barh`                       Make a horizontal bar plot.                                                                                                                                                           \n",
      "        `box`                        Turn the axes box on or off.                                                                                                                                                          \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 contours.                                                                                                                                                                        \n",
      "        `contourf`                   Plot contours.                                                                                                                                                                        \n",
      "        `csd`                        Plot the cross-spectral density.                                                                                                                                                      \n",
      "        `delaxes`                    Remove the given `Axes` *ax* from the current 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`                   Adds a non-resampled image to the figure.                                                                                                                                             \n",
      "        `figlegend`                  Place a legend in the figure.                                                                                                                                                         \n",
      "        `fignum_exists`                                                                                                                                                                                                    \n",
      "        `figtext`                    Add text to figure.                                                                                                                                                                   \n",
      "        `figure`                     Creates a new 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 :class:`~matplotlib.axes.Axes` instance on the     current figure matching the given keyword args, or create one.                                                     \n",
      "        `gcf`                        Get a reference to the current figure.                                                                                                                                                \n",
      "        `gci`                        Get the current colorable artist.                                                                                                                                                     \n",
      "        `get_figlabels`              Return a list of existing figure labels.                                                                                                                                              \n",
      "        `get_fignums`                Return a list of existing figure numbers.                                                                                                                                             \n",
      "        `grid`                       Turn the axes grids on or off.                                                                                                                                                        \n",
      "        `hexbin`                     Make a hexagonal binning plot.                                                                                                                                                        \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",
      "        `hold`                       ..                                                                                                                                                                                    \n",
      "        `imread`                     Read an image from a file into an array.                                                                                                                                              \n",
      "        `imsave`                     Save an array as in image file.                                                                                                                                                       \n",
      "        `imshow`                     Display an image on the axes.                                                                                                                                                         \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`                       Turn interactive mode off.                                                                                                                                                            \n",
      "        `ion`                        Turn interactive mode on.                                                                                                                                                             \n",
      "        `ishold`                     ..                                                                                                                                                                                    \n",
      "        `isinteractive`              Return status of interactive mode.                                                                                                                                                    \n",
      "        `legend`                     Places a legend on the axes.                                                                                                                                                          \n",
      "        `locator_params`             Control behavior of 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 current plot.                                                                                                                                             \n",
      "        `minorticks_on`              Display minor ticks on the current plot.                                                                                                                                              \n",
      "        `over`                       ..                                                                                                                                                                                    \n",
      "        `pause`                      Pause for *interval* seconds.                                                                                                                                                         \n",
      "        `pcolor`                     Create a pseudocolor plot of a 2-D array.                                                                                                                                             \n",
      "        `pcolormesh`                 Plot a quadrilateral mesh.                                                                                                                                                            \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 data that contains dates.                                                                                                                                                        \n",
      "        `plotfile`                   Plot the data in a file.                                                                                                                                                              \n",
      "        `polar`                      Make a polar plot.                                                                                                                                                                    \n",
      "        `psd`                        Plot the power spectral density.                                                                                                                                                      \n",
      "        `quiver`                     Plot a 2-D field of arrows.                                                                                                                                                           \n",
      "        `quiverkey`                  Add a key to a quiver plot.                                                                                                                                                           \n",
      "        `rc`                         Set the current rc params.                                                                                                                                                            \n",
      "        `rc_context`                 Return a context manager for managing rc settings.                                                                                                                                    \n",
      "        `rcdefaults`                 Restore the rc params from Matplotlib's internal defaults.                                                                                                                            \n",
      "        `rgrids`                     Get or set the radial gridlines on a polar plot.                                                                                                                                      \n",
      "        `savefig`                    Save the current figure.                                                                                                                                                              \n",
      "        `sca`                        Set the current Axes instance to *ax*.                                                                                                                                                \n",
      "        `scatter`                    A scatter plot of *y* vs *x* with varying marker size and/or color.                                                                                                                   \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.                                                                                                                                                             \n",
      "        `setp`                       Set a property on an artist object.                                                                                                                                                   \n",
      "        `show`                       Display a figure.                                                                                                                                                                     \n",
      "        `specgram`                   Plot a spectrogram.                                                                                                                                                                   \n",
      "        `spectral`                   Set the colormap to \"spectral\".                                                                                                                                                       \n",
      "        `spy`                        Plot the sparsity pattern on a 2-D array.                                                                                                                                             \n",
      "        `stackplot`                  Draws a stacked area plot.                                                                                                                                                            \n",
      "        `stem`                       Create a stem plot.                                                                                                                                                                   \n",
      "        `step`                       Make a step plot.                                                                                                                                                                     \n",
      "        `streamplot`                 Draws streamlines of a vector flow.                                                                                                                                                   \n",
      "        `subplot`                    Return a subplot axes at the given grid position.                                                                                                                                     \n",
      "        `subplot2grid`               Create an axis at specific location inside a regular grid.                                                                                                                            \n",
      "        `subplot_tool`               Launch a subplot tool window for a figure.                                                                                                                                            \n",
      "        `subplots`                   Create a figure and a set of subplots      This utility wrapper makes it convenient to create common layouts of     subplots, including the enclosing figure object, in a single call.\n",
      "        `subplots_adjust`            Tune the subplot layout.                                                                                                                                                              \n",
      "        `suptitle`                   Add a centered title to the figure.                                                                                                                                                   \n",
      "        `switch_backend`             Switch the default backend.                                                                                                                                                           \n",
      "        `table`                      Add a table to the current axes.                                                                                                                                                      \n",
      "        `text`                       Add text to the axes.                                                                                                                                                                 \n",
      "        `thetagrids`                 Get or set the theta locations of the gridlines in a polar plot.                                                                                                                      \n",
      "        `tick_params`                Change the appearance of ticks, tick labels, and gridlines.                                                                                                                           \n",
      "        `ticklabel_format`           Change the `~matplotlib.ticker.ScalarFormatter` used by default for linear axes.                                                                                                      \n",
      "        `tight_layout`               Automatically adjust subplot parameters to give specified padding.                                                                                                                    \n",
      "        `title`                      Set a title of the current axes.                                                                                                                                                      \n",
      "        `tricontour`                 Draw contours on an unstructured triangular grid.                                                                                                                                     \n",
      "        `tricontourf`                Draw contours 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 a second axes that shares the *x*-axis.                                                                                                                                          \n",
      "        `twiny`                      Make a second axes that shares the *y*-axis.                                                                                                                                          \n",
      "        `uninstall_repl_displayhook` Uninstalls the matplotlib display hook.                                                                                                                                               \n",
      "        `violinplot`                 Make a violin plot.                                                                                                                                                                   \n",
      "        `vlines`                     Plot vertical lines.                                                                                                                                                                  \n",
      "        `xcorr`                      Plot the cross correlation between *x* and *y*.                                                                                                                                       \n",
      "        `xkcd`                       Turns on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.                                                                                                                       \n",
      "        `xlabel`                     Set the x-axis label of the current axes.                                                                                                                                             \n",
      "        `xlim`                       Get or set the x limits of the current axes.                                                                                                                                          \n",
      "        `xscale`                     Set the scaling of the x-axis.                                                                                                                                                        \n",
      "        `xticks`                     Get or set the current tick locations and labels of the x-axis.                                                                                                                       \n",
      "        `ylabel`                     Set the y-axis label of the current axes.                                                                                                                                             \n",
      "        `ylim`                       Get or set the y-limits of the current axes.                                                                                                                                          \n",
      "        `yscale`                     Set the scaling of the y-axis.                                                                                                                                                        \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\n",
      "        strings, as in :func:`~matplotlib.pyplot.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, hold=None, data=None, **kwargs)\n",
      "        Plot the power spectral density.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          psd(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n",
      "              window=mlab.window_hanning, noverlap=0, pad_to=None,\n",
      "              sides='default', scale_by_freq=None, return_line=None, **kwargs)\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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between segments.\n",
      "            The default value is 0 (no overlap).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        return_line : bool\n",
      "            Whether to include the line object plotted in the returned values.\n",
      "            Default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Pxx : 1-D array\n",
      "            The values for the power spectrum `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 : a :class:`~matplotlib.lines.Line2D` instance\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 :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`specgram`\n",
      "            :func:`specgram` differs in the default overlap; in not returning\n",
      "            the mean of the segment periodograms; in returning the times of the\n",
      "            segments; and in plotting a colormap instead of a line.\n",
      "        \n",
      "        :func:`magnitude_spectrum`\n",
      "            :func:`magnitude_spectrum` plots the magnitude spectrum.\n",
      "        \n",
      "        :func:`csd`\n",
      "            :func:`csd` 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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    quiver(*args, **kw)\n",
      "        Plot a 2-D field of arrows.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          quiver(U, V, **kw)\n",
      "          quiver(U, V, C, **kw)\n",
      "          quiver(X, Y, U, V, **kw)\n",
      "          quiver(X, Y, U, V, C, **kw)\n",
      "        \n",
      "        *U* and *V* are the arrow data, *X* and *Y* set the location of the\n",
      "        arrows, and *C* sets the color of the arrows. These arguments may be 1-D or\n",
      "        2-D arrays or sequences.\n",
      "        \n",
      "        If *X* and *Y* are absent, they will be generated as a uniform grid.\n",
      "        If *U* and *V* are 2-D arrays and *X* and *Y* are 1-D, and if ``len(X)`` and\n",
      "        ``len(Y)`` match the column and row dimensions of *U*, then *X* and *Y* will be\n",
      "        expanded with :func:`numpy.meshgrid`.\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* kwargs.\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",
      "        *linewidths* and *edgecolors* can be used to customize the arrow\n",
      "        outlines.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X : 1D or 2D array, sequence, optional\n",
      "            The x coordinates of the arrow locations\n",
      "        Y : 1D or 2D array, sequence, optional\n",
      "            The y coordinates of the arrow locations\n",
      "        U : 1D or 2D array or masked array, sequence\n",
      "            The x components of the arrow vectors\n",
      "        V : 1D or 2D array or masked array, sequence\n",
      "            The y components of the arrow vectors\n",
      "        C : 1D or 2D array, sequence, optional\n",
      "            The arrow colors\n",
      "        units : [ 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y' | 'xy' ]\n",
      "            The arrow dimensions (except for *length*) are measured in multiples of\n",
      "            this unit.\n",
      "        \n",
      "            'width' or 'height': the width or height of the axis\n",
      "        \n",
      "            'dots' or 'inches': pixels or inches, based on the figure dpi\n",
      "        \n",
      "            'x', 'y', or 'xy': respectively *X*, *Y*, or :math:`\\sqrt{X^2 + Y^2}`\n",
      "            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",
      "        angles : [ 'uv' | 'xy' ], array, optional\n",
      "            Method for determining the angle of the arrows. Default is 'uv'.\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",
      "            '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 as an array\n",
      "            of values in degrees, counter-clockwise from the horizontal axis.\n",
      "        \n",
      "            Note: inverting a data axis will correspondingly invert the\n",
      "            arrows only with ``angles='xy'``.\n",
      "        scale : None, 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",
      "        scale_units : [ 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y' | 'xy' ], None, 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\n",
      "            ``(u,v) = (1,0)``, then the vector will be 0.5 inches long.\n",
      "        \n",
      "            If *scale_units* is 'width'/'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",
      "        width : scalar, 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",
      "        headwidth : scalar, optional\n",
      "            Head width as multiple of shaft width, default is 3\n",
      "        headlength : scalar, optional\n",
      "            Head length as multiple of shaft width, default is 5\n",
      "        headaxislength : scalar, optional\n",
      "            Head length at shaft intersection, default is 4.5\n",
      "        minshaft : scalar, optional\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",
      "            Default is 1\n",
      "        minlength : scalar, optional\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",
      "            Default is 1.\n",
      "        pivot : [ 'tail' | 'mid' | 'middle' | 'tip' ], optional\n",
      "            The part of the arrow that is at the grid point; the arrow rotates\n",
      "            about this point, hence the name *pivot*.\n",
      "        color : [ color | color sequence ], optional\n",
      "            This is a synonym for the\n",
      "            :class:`~matplotlib.collections.PolyCollection` facecolor kwarg.\n",
      "            If *C* has been set, *color* has no effect.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Additional :class:`~matplotlib.collections.PolyCollection`\n",
      "        keyword arguments:\n",
      "        \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: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          capstyle: unknown\n",
      "          clim: a length 2 sequence of floats; may be overridden in methods that have ``vmin`` and ``vmax`` kwargs. \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          joinstyle: unknown\n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        quiverkey : Add a key to a quiver plot\n",
      "    \n",
      "    quiverkey(*args, **kw)\n",
      "        Add a key to a quiver plot.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          quiverkey(Q, X, Y, U, label, **kw)\n",
      "        \n",
      "        Arguments:\n",
      "        \n",
      "          *Q*:\n",
      "            The Quiver instance returned by a call to quiver.\n",
      "        \n",
      "          *X*, *Y*:\n",
      "            The location of the key; additional explanation follows.\n",
      "        \n",
      "          *U*:\n",
      "            The length of the key\n",
      "        \n",
      "          *label*:\n",
      "            A string with the length and units of the key\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *angle* = 0\n",
      "            The angle of the key arrow. Measured in degrees anti-clockwise from the\n",
      "            x-axis.\n",
      "        \n",
      "          *coordinates* = [ 'axes' | 'figure' | 'data' | 'inches' ]\n",
      "            Coordinate system and units for *X*, *Y*: 'axes' and 'figure' are\n",
      "            normalized coordinate systems with 0,0 in the lower left and 1,1\n",
      "            in the upper right; 'data' are the axes data coordinates (used for\n",
      "            the locations of the vectors in the quiver plot itself); 'inches'\n",
      "            is position in the figure in inches, with 0,0 at the lower left\n",
      "            corner.\n",
      "        \n",
      "          *color*:\n",
      "            overrides face and edge colors from *Q*.\n",
      "        \n",
      "          *labelpos* = [ 'N' | 'S' | 'E' | 'W' ]\n",
      "            Position the label above, below, to the right, to the left of the\n",
      "            arrow, respectively.\n",
      "        \n",
      "          *labelsep*:\n",
      "            Distance in inches between the arrow and the label.  Default is\n",
      "            0.1\n",
      "        \n",
      "          *labelcolor*:\n",
      "            defaults to default :class:`~matplotlib.text.Text` color.\n",
      "        \n",
      "          *fontproperties*:\n",
      "            A dictionary with keyword arguments accepted by the\n",
      "            :class:`~matplotlib.font_manager.FontProperties` initializer:\n",
      "            *family*, *style*, *variant*, *size*, *weight*\n",
      "        \n",
      "        Any additional keyword arguments are used to override vector\n",
      "        properties taken from *Q*.\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\n",
      "        of the middle of the key arrow.  If *labelpos* is 'E', *X*, *Y*\n",
      "        positions the head, and if *labelpos* is 'W', *X*, *Y* positions the\n",
      "        tail; in either of these two cases, *X*, *Y* is somewhere in the\n",
      "        middle of the arrow+label key object.\n",
      "    \n",
      "    rc(*args, **kwargs)\n",
      "        Set the current rc params.  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 rc params 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\n",
      "        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 rc command as::\n",
      "        \n",
      "              rc('lines', lw=2, c='r')\n",
      "        \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",
      "        \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 rc params after changes.\n",
      "    \n",
      "    rc_context(rc=None, fname=None)\n",
      "        Return a context manager for managing rc settings.\n",
      "        \n",
      "        This allows one to do::\n",
      "        \n",
      "            with mpl.rc_context(fname='screen.rc'):\n",
      "                plt.plot(x, a)\n",
      "                with mpl.rc_context(fname='print.rc'):\n",
      "                    plt.plot(x, b)\n",
      "                plt.plot(x, c)\n",
      "        \n",
      "        The 'a' vs 'x' and 'c' vs 'x' plots would have settings from\n",
      "        'screen.rc', while the 'b' vs 'x' plot would have settings from\n",
      "        'print.rc'.\n",
      "        \n",
      "        A dictionary can also be passed to the context manager::\n",
      "        \n",
      "            with mpl.rc_context(rc={'text.usetex': True}, fname='screen.rc'):\n",
      "                plt.plot(x, a)\n",
      "        \n",
      "        The 'rc' dictionary takes precedence over the settings loaded from\n",
      "        'fname'.  Passing a dictionary only is also valid. For example a\n",
      "        common usage is::\n",
      "        \n",
      "            with mpl.rc_context(rc={'interactive': False}):\n",
      "                fig, ax = plt.subplots()\n",
      "                ax.plot(range(3), range(3))\n",
      "                fig.savefig('A.png', format='png')\n",
      "                plt.close(fig)\n",
      "    \n",
      "    rcdefaults()\n",
      "        Restore the rc params from Matplotlib's internal defaults.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rc_file_defaults :\n",
      "            Restore the rc params from the rc file originally loaded by Matplotlib.\n",
      "        matplotlib.style.use :\n",
      "            Use a specific style file.  Call ``style.use('default')`` to restore\n",
      "            the default style.\n",
      "    \n",
      "    rgrids(*args, **kwargs)\n",
      "        Get or set the radial gridlines on a polar plot.\n",
      "        \n",
      "        call signatures::\n",
      "        \n",
      "          lines, labels = rgrids()\n",
      "          lines, labels = rgrids(radii, labels=None, angle=22.5, **kwargs)\n",
      "        \n",
      "        When called with no arguments, :func:`rgrid` simply returns the\n",
      "        tuple (*lines*, *labels*), where *lines* is an array of radial\n",
      "        gridlines (:class:`~matplotlib.lines.Line2D` instances) and\n",
      "        *labels* is an array of tick labels\n",
      "        (:class:`~matplotlib.text.Text` instances). When called with\n",
      "        arguments, the labels will appear at the specified radial\n",
      "        distances and angles.\n",
      "        \n",
      "        *labels*, if not *None*, is a len(*radii*) list of strings of the\n",
      "        labels to use at each angle.\n",
      "        \n",
      "        If *labels* is None, the rformatter will be used\n",
      "        \n",
      "        Examples::\n",
      "        \n",
      "          # set the locations of the radial gridlines and labels\n",
      "          lines, labels = rgrids( (0.25, 0.5, 1.0) )\n",
      "        \n",
      "          # set the locations and labels of the radial gridlines and labels\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)\n",
      "        \n",
      "        The output formats available depend on the backend being used.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        fname : str or file-like object\n",
      "            A string containing a path to a filename, or a Python\n",
      "            file-like object, or possibly some backend-dependent object\n",
      "            such as :class:`~matplotlib.backends.backend_pdf.PdfPages`.\n",
      "        \n",
      "            If *format* is *None* and *fname* is a string, the output\n",
      "            format is deduced from the extension of the filename. If\n",
      "            the filename has no extension, the value of the rc parameter\n",
      "            ``savefig.format`` is used.\n",
      "        \n",
      "            If *fname* is not a string, remember to specify *format* to\n",
      "            ensure that the correct backend is used.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        dpi : [ *None* | scalar > 0 | 'figure']\n",
      "            The resolution in dots per inch.  If *None* it will default to\n",
      "            the value ``savefig.dpi`` in the matplotlibrc file. If 'figure'\n",
      "            it will set the dpi to be the value of the figure.\n",
      "        \n",
      "        facecolor : color spec or None, optional\n",
      "            the facecolor of the figure; if None, defaults to savefig.facecolor\n",
      "        \n",
      "        edgecolor : color spec or None, optional\n",
      "            the edgecolor of the figure; if None, defaults to savefig.edgecolor\n",
      "        \n",
      "        orientation : {'landscape', 'portrait'}\n",
      "            not supported on all backends; currently only on postscript output\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",
      "            One of the file extensions supported by the active\n",
      "            backend.  Most backends support png, pdf, ps, eps and svg.\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",
      "        frameon : bool\n",
      "            If *True*, the figure patch will be colored, if *False*, the\n",
      "            figure background will be transparent.  If not provided, the\n",
      "            rcParam 'savefig.frameon' will be used.\n",
      "        \n",
      "        bbox_inches : str or `~matplotlib.transforms.Bbox`, optional\n",
      "            Bbox in inches. Only the given portion of the figure is\n",
      "            saved. If 'tight', try to figure out the tight bbox of\n",
      "            the figure. If None, use savefig.bbox\n",
      "        \n",
      "        pad_inches : scalar, optional\n",
      "            Amount of padding around the figure when bbox_inches is\n",
      "            'tight'. If None, use savefig.pad_inches\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",
      "    sca(ax)\n",
      "        Set the current Axes instance to *ax*.\n",
      "        \n",
      "        The current Figure is updated 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, verts=None, edgecolors=None, hold=None, 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 : array_like, shape (n, )\n",
      "            The data positions.\n",
      "        \n",
      "        s : scalar or array_like, shape (n, ), optional\n",
      "            The marker size in points**2.\n",
      "            Default is ``rcParams['lines.markersize'] ** 2``.\n",
      "        \n",
      "        c : color, sequence, or sequence of color, optional, default: 'b'\n",
      "            The marker color. Possible values:\n",
      "        \n",
      "            - A single color format string.\n",
      "            - A sequence of color specifications of length n.\n",
      "            - A sequence of n numbers to be mapped to colors using *cmap* and\n",
      "              *norm*.\n",
      "            - A 2-D array in which the rows are RGB or RGBA.\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 2-D array with a single row.\n",
      "        \n",
      "        marker : `~matplotlib.markers.MarkerStyle`, optional, default: 'o'\n",
      "            The marker style. *marker* can be either an instance of the class\n",
      "            or the text shorthand for a particular marker.\n",
      "            See `~matplotlib.markers` for more information marker styles.\n",
      "        \n",
      "        cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "            A `.Colormap` instance or registered colormap name. *cmap* is only\n",
      "            used if *c* is an array of floats. If ``None``, defaults to rc\n",
      "            ``image.cmap``.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional, default: None\n",
      "            A `.Normalize` instance is used to scale luminance data to 0, 1.\n",
      "            *norm* is only used if *c* is an array of floats. If *None*, use\n",
      "            the default `.colors.Normalize`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default: None\n",
      "            *vmin* and *vmax* are used in conjunction with *norm* to normalize\n",
      "            luminance data. If None, the respective min and max of the color\n",
      "            array is used. *vmin* and *vmax* are ignored if you pass a *norm*\n",
      "            instance.\n",
      "        \n",
      "        alpha : scalar, optional, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        linewidths : scalar or array_like, optional, default: None\n",
      "            The linewidth of the marker edges. Note: The default *edgecolors*\n",
      "            is 'face'. You may want to change this as well.\n",
      "            If *None*, defaults to rcParams ``lines.linewidth``.\n",
      "        \n",
      "        verts : sequence of (x, y), optional\n",
      "            If *marker* is *None*, these vertices will be used to construct\n",
      "            the marker.  The center of the marker is located at (0, 0) in\n",
      "            normalized units.  The overall marker is rescaled by *s*.\n",
      "        \n",
      "        edgecolors : color or sequence of color, optional, default: 'face'\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 matplotib color.\n",
      "        \n",
      "            For non-filled markers, the *edgecolors* kwarg is ignored and\n",
      "            forced to 'face' internally.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        paths : `~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",
      "        \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 1-D arrays; *x*, *y*, *s*, and *c*\n",
      "          may be input as 2-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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'c', 'color', 'edgecolors', 'facecolor', 'facecolors', 'linewidths', 's', 'x', 'y'.\n",
      "    \n",
      "    sci(im)\n",
      "        Set the current image.  This image will be the target of colormap\n",
      "        commands like :func:`~matplotlib.pyplot.jet`,\n",
      "        :func:`~matplotlib.pyplot.hot` or\n",
      "        :func:`~matplotlib.pyplot.clim`).  The current image is an\n",
      "        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 *basex*, *subsx* and *nonposx* control the\n",
      "        x-axis properties. They are just forwarded to `.Axes.set_xscale`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        basex : scalar, optional, default 10\n",
      "            Base of the x logarithm.\n",
      "        \n",
      "        subsx : 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",
      "        nonposx : {'mask', 'clip'}, optional, 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",
      "        lines\n",
      "            A list of `~.Line2D` 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 *basey*, *subsy* and *nonposy* control the\n",
      "        y-axis properties. They are just forwarded to `.Axes.set_yscale`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        basey : scalar, optional, default 10\n",
      "            Base of the y logarithm.\n",
      "        \n",
      "        subsy : 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",
      "        nonposy : {'mask', 'clip'}, optional, 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",
      "        lines\n",
      "            A list of `~.Line2D` 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.  Applies to the current image if any.\n",
      "        See help(colormaps) for more information.\n",
      "        \n",
      "        *cmap* must be a :class:`~matplotlib.colors.Colormap` instance, or\n",
      "        the name of a registered colormap.\n",
      "        \n",
      "        See :func:`matplotlib.cm.register_cmap` and\n",
      "        :func:`matplotlib.cm.get_cmap`.\n",
      "    \n",
      "    setp(*args, **kwargs)\n",
      "        Set a property on an artist object.\n",
      "        \n",
      "        matplotlib supports the use of :func:`setp` (\"set property\") and\n",
      "        :func:`getp` to set and get object properties, as well as to do\n",
      "        introspection on the object.  For example, to set the linestyle of a\n",
      "        line to be dashed, you can do::\n",
      "        \n",
      "          >>> line, = plot([1,2,3])\n",
      "          >>> setp(line, linestyle='--')\n",
      "        \n",
      "        If you want to know the valid types of arguments, you can provide\n",
      "        the name of the property you want to set without a value::\n",
      "        \n",
      "          >>> setp(line, 'linestyle')\n",
      "              linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]\n",
      "        \n",
      "        If you want to see all the properties that can be set, and their\n",
      "        possible values, you can do::\n",
      "        \n",
      "          >>> setp(line)\n",
      "              ... long output listing omitted\n",
      "        \n",
      "        You may specify another output file to `setp` if `sys.stdout` is not\n",
      "        acceptable for some reason using the `file` keyword-only argument::\n",
      "        \n",
      "          >>> with fopen('output.log') as f:\n",
      "          >>>     setp(line, file=f)\n",
      "        \n",
      "        :func:`setp` operates on a single instance or a iterable of\n",
      "        instances. If you are in query mode introspecting the possible\n",
      "        values, only the first instance in the sequence is used. When\n",
      "        actually setting values, all the instances will be set.  e.g.,\n",
      "        suppose you have a list of two lines, the following will make both\n",
      "        lines thicker and red::\n",
      "        \n",
      "          >>> x = arange(0,1.0,0.01)\n",
      "          >>> y1 = sin(2*pi*x)\n",
      "          >>> y2 = sin(4*pi*x)\n",
      "          >>> lines = plot(x, y1, x, y2)\n",
      "          >>> setp(lines, linewidth=2, color='r')\n",
      "        \n",
      "        :func:`setp` works with the MATLAB style string/value pairs or\n",
      "        with python kwargs.  For example, the following are equivalent::\n",
      "        \n",
      "          >>> setp(lines, 'linewidth', 2, 'color', 'r')  # MATLAB style\n",
      "          >>> setp(lines, linewidth=2, color='r')        # python style\n",
      "    \n",
      "    show(*args, **kw)\n",
      "        Display a figure.\n",
      "        When running in ipython with its pylab mode, display all\n",
      "        figures and return to the ipython prompt.\n",
      "        \n",
      "        In non-interactive mode, display all figures and block until\n",
      "        the figures have been closed; in interactive mode it has no\n",
      "        effect unless figures were created prior to a change from\n",
      "        non-interactive to interactive mode (not recommended).  In\n",
      "        that case it displays the figures but does not block.\n",
      "        \n",
      "        A single experimental keyword argument, *block*, may be\n",
      "        set to True or False to override the blocking behavior\n",
      "        described above.\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, hold=None, data=None, **kwargs)\n",
      "        Plot a spectrogram.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          specgram(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n",
      "                   window=mlab.window_hanning, noverlap=128,\n",
      "                   cmap=None, xextent=None, pad_to=None, sides='default',\n",
      "                   scale_by_freq=None, mode='default', scale='default',\n",
      "                   **kwargs)\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 : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        mode : [ 'default' | 'psd' | 'magnitude' | 'angle' | 'phase' ]\n",
      "            What sort of spectrum to use.  Default is 'psd', which takes\n",
      "            the power spectral density.  'complex' returns the complex-valued\n",
      "            frequency spectrum.  'magnitude' returns the magnitude spectrum.\n",
      "            'angle' returns the phase spectrum without unwrapping.  'phase'\n",
      "            returns the phase spectrum with unwrapping.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between blocks.  The\n",
      "            default value is 128.\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 : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        cmap :\n",
      "            A :class:`matplotlib.colors.Colormap` instance; if *None*, use\n",
      "            default determined by rc\n",
      "        \n",
      "        xextent : [None | (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 kwargs are passed on to imshow which makes the\n",
      "            specgram image\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 2-D 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 : instance of class :class:`~matplotlib.image.AxesImage`\n",
      "            The image created by imshow containing the spectrogram\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`psd`\n",
      "            :func:`psd` differs in the default overlap; in returning the mean\n",
      "            of the segment periodograms; in not returning times; and in\n",
      "            generating a line plot instead of colormap.\n",
      "        \n",
      "        :func:`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",
      "        \n",
      "        :func:`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",
      "        \n",
      "        :func:`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 a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    spectral()\n",
      "        Set the colormap to \"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",
      "    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', **kwargs)\n",
      "        Plot the sparsity pattern on a 2-D array.\n",
      "        \n",
      "        ``spy(Z)`` plots the sparsity pattern of the 2-D array *Z*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        Z : sparse array (n, m)\n",
      "            The array to be plotted.\n",
      "        \n",
      "        precision : float, optional, default: 0\n",
      "            If *precision* is 0, any non-zero value will be plotted; else,\n",
      "            values of :math:`|Z| > precision` will be plotted.\n",
      "        \n",
      "            For :class:`scipy.sparse.spmatrix` instances, there is a special\n",
      "            case: if *precision* is 'present', any value present in the array\n",
      "            will be plotted, even if it is identically zero.\n",
      "        \n",
      "        origin : [\"upper\", \"lower\"], optional, default: \"upper\"\n",
      "            Place the [0,0] index of the array in the upper left or lower left\n",
      "            corner of the axes.\n",
      "        \n",
      "        aspect : ['auto' | 'equal' | scalar], optional, default: \"equal\"\n",
      "        \n",
      "            If 'equal', and `extent` is None, changes the axes aspect ratio to\n",
      "            match that of the image. If `extent` is not `None`, the axes\n",
      "            aspect ratio is changed to match that of the extent.\n",
      "        \n",
      "        \n",
      "            If 'auto', changes the image aspect ratio to match that of the\n",
      "            axes.\n",
      "        \n",
      "            If None, default to rc ``image.aspect`` value.\n",
      "        \n",
      "        Two plotting styles are available: image or marker. Both\n",
      "        are available for full arrays, but only the marker style\n",
      "        works for :class:`scipy.sparse.spmatrix` instances.\n",
      "        \n",
      "        If *marker* and *markersize* are *None*, an image will be\n",
      "        returned and any remaining kwargs are passed to\n",
      "        :func:`~matplotlib.pyplot.imshow`; else, a\n",
      "        :class:`~matplotlib.lines.Line2D` object will be returned with\n",
      "        the value of marker determining the marker type, and any\n",
      "        remaining kwargs passed to the\n",
      "        :meth:`~matplotlib.axes.Axes.plot` method.\n",
      "        \n",
      "        If *marker* and *markersize* are *None*, useful kwargs include:\n",
      "        \n",
      "        * *cmap*\n",
      "        * *alpha*\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        imshow : for image options.\n",
      "        plot : for plotting options\n",
      "    \n",
      "    stackplot(x, *args, **kwargs)\n",
      "        Draws a stacked area plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1d array of dimension N\n",
      "        \n",
      "        y : 2d array (dimension MxN), or sequence of 1d arrays (each dimension 1xN)\n",
      "        \n",
      "            The data is assumed to be unstacked. Each of the following\n",
      "            calls is legal::\n",
      "        \n",
      "                stackplot(x, y)               # where y is MxN\n",
      "                stackplot(x, y1, y2, y3, y4)  # where y1, y2, y3, y4, are all 1xNm\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 : Length N sequence of strings\n",
      "            Labels to assign to each data series.\n",
      "        \n",
      "        colors : Length N sequence of colors\n",
      "            A list or tuple of colors. These will be cycled through and used to\n",
      "            colour the stacked areas.\n",
      "        \n",
      "        **kwargs :\n",
      "            All other keyword arguments are passed to `Axes.fill_between()`.\n",
      "        \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",
      "    stem(*args, **kwargs)\n",
      "        Create a stem plot.\n",
      "        \n",
      "        A stem plot plots vertical lines at each *x* location from the baseline\n",
      "        to *y*, and places a marker there.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          stem([x,] y, linefmt=None, markerfmt=None, basefmt=None)\n",
      "        \n",
      "        The x-positions are optional. The formats may be provided either as\n",
      "        positional or as keyword-arguments.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array-like, optional\n",
      "            The x-positions of the stems. Default: (0, 1, ..., len(y) - 1).\n",
      "        \n",
      "        y : array-like\n",
      "            The y-values of the stem heads.\n",
      "        \n",
      "        linefmt : str, optional\n",
      "            A string defining the properties of the vertical lines. Usually,\n",
      "            this will be a color or a color and a linestyle:\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: While it is technically possible to specify valid formats\n",
      "            other than color or color and linestyle (e.g. 'rx' or '-.'), this\n",
      "            is beyond the intention of the method and will most likely not\n",
      "            result in a reasonable reasonable plot.\n",
      "        \n",
      "        markerfmt : str, optional\n",
      "            A string defining the properties of the markers at the stem heads.\n",
      "            Default: 'C0o', i.e. filled circles with the first color of the\n",
      "            color cycle.\n",
      "        \n",
      "        basefmt : str, optional\n",
      "            A format string defining the properties of the baseline.\n",
      "        \n",
      "            Default: 'C3-' ('C2-' in classic mode).\n",
      "        \n",
      "        bottom : float, optional, default: 0\n",
      "            The y-position of the baseline.\n",
      "        \n",
      "        label : str, optional, default: None\n",
      "            The label to use for the stems in legends.\n",
      "        \n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            No other parameters are supported. They are currently ignored\n",
      "            silently for backward compatibility. This behavior is deprecated.\n",
      "            Future versions will not accept any other parameters and will\n",
      "            raise a TypeError instead.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`~matplotlib.container.StemContainer`\n",
      "            The stemcontainer may be treated like a tuple\n",
      "            (*markerline*, *stemlines*, *baseline*)\n",
      "        \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. seealso::\n",
      "            The MATLAB function\n",
      "            `stem <http://www.mathworks.com/help/techdoc/ref/stem.html>`_\n",
      "            which inspired this method.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    step(x, y, *args, **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",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            1-D sequence of x positions. It is assumed, but not checked, that\n",
      "            it is uniformly increasing.\n",
      "        \n",
      "        y : array_like\n",
      "            1-D 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'}, optional, 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",
      "        lines\n",
      "            A list of `.Line2D` 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",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\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', hold=None, data=None)\n",
      "        Draws streamlines of a vector flow.\n",
      "        \n",
      "        *x*, *y* : 1d arrays\n",
      "            an *evenly spaced* grid.\n",
      "        *u*, *v* : 2d arrays\n",
      "            x and y-velocities. Number of rows should match length of y, and\n",
      "            the number of columns should match x.\n",
      "        *density* : float or 2-tuple\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 [density_x, density_y].\n",
      "        *linewidth* : numeric or 2d array\n",
      "            vary linewidth when given a 2d array with the same shape as velocities.\n",
      "        *color* : matplotlib color code, or 2d array\n",
      "            Streamline color. When given an array with the same shape as\n",
      "            velocities, *color* values are converted to colors using *cmap*.\n",
      "        *cmap* : :class:`~matplotlib.colors.Colormap`\n",
      "            Colormap used to plot streamlines and arrows. Only necessary when using\n",
      "            an array input for *color*.\n",
      "        *norm* : :class:`~matplotlib.colors.Normalize`\n",
      "            Normalize object used to scale luminance data to 0, 1. If None, stretch\n",
      "            (min, max) to (0, 1). Only necessary when *color* is an array.\n",
      "        *arrowsize* : float\n",
      "            Factor scale arrow size.\n",
      "        *arrowstyle* : str\n",
      "            Arrow style specification.\n",
      "            See :class:`~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.\n",
      "            In data coordinates, the same as the ``x`` and ``y`` arrays.\n",
      "        *zorder* : int\n",
      "            any number\n",
      "        *maxlength* : float\n",
      "            Maximum length of streamline in axes coordinates.\n",
      "        *integration_direction* : ['forward', 'backward', 'both']\n",
      "            Integrate the streamline in forward, backward or both directions.\n",
      "        \n",
      "        Returns:\n",
      "        \n",
      "            *stream_container* : StreamplotSet\n",
      "                Container object with attributes\n",
      "        \n",
      "                    - lines: `matplotlib.collections.LineCollection` of streamlines\n",
      "        \n",
      "                    - arrows: collection of `matplotlib.patches.FancyArrowPatch`\n",
      "                      objects representing arrows half-way along stream\n",
      "                      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",
      "    subplot(*args, **kwargs)\n",
      "        Return a subplot axes at the given grid position.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "           subplot(nrows, ncols, index, **kwargs)\n",
      "        \n",
      "        In the current figure, create and return an `.Axes`, at position *index*\n",
      "        of a (virtual) grid of *nrows* by *ncols* axes.  Indexes go from 1 to\n",
      "        ``nrows * ncols``, incrementing in row-major order.\n",
      "        \n",
      "        If *nrows*, *ncols* and *index* are all less than 10, they can also be\n",
      "        given as a single, concatenated, three-digit number.\n",
      "        \n",
      "        For example, ``subplot(2, 3, 3)`` and ``subplot(233)`` both create an\n",
      "        `.Axes` at the top right corner of the current figure, occupying half of\n",
      "        the figure height and a third of the figure width.\n",
      "        \n",
      "        .. note::\n",
      "        \n",
      "           Creating a subplot will delete any pre-existing subplot that overlaps\n",
      "           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",
      "              plt.plot(range(12))\n",
      "              plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background\n",
      "        \n",
      "           If you do not want this behavior, use the\n",
      "           :meth:`~matplotlib.figure.Figure.add_subplot` method or the\n",
      "           :func:`~matplotlib.pyplot.axes` function instead.\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *facecolor*:\n",
      "            The background color of the subplot, which can be any valid\n",
      "            color specifier.  See :mod:`matplotlib.colors` for more\n",
      "            information.\n",
      "        \n",
      "          *polar*:\n",
      "            A boolean flag indicating whether the subplot plot should be\n",
      "            a polar projection.  Defaults to *False*.\n",
      "        \n",
      "          *projection*:\n",
      "            A string giving the name of a custom projection to be used\n",
      "            for the subplot. This projection must have been previously\n",
      "            registered. See :mod:`matplotlib.projections`.\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`~matplotlib.pyplot.axes`\n",
      "                For additional information on :func:`axes` and\n",
      "                :func:`subplot` keyword arguments.\n",
      "        \n",
      "            :file:`gallery/pie_and_polar_charts/polar_scatter.py`\n",
      "                For an example\n",
      "        \n",
      "        **Example:**\n",
      "        \n",
      "        .. plot:: gallery/subplots_axes_and_figures/subplot.py\n",
      "    \n",
      "    subplot2grid(shape, loc, rowspan=1, colspan=1, fig=None, **kwargs)\n",
      "        Create an axis at specific location inside a regular grid.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        shape : sequence of 2 ints\n",
      "            Shape of grid in which to place axis.\n",
      "            First entry is number of rows, second entry is number of columns.\n",
      "        \n",
      "        loc : sequence of 2 ints\n",
      "            Location to place axis within grid.\n",
      "            First entry is row number, second entry is column number.\n",
      "        \n",
      "        rowspan : int\n",
      "            Number of rows for the axis to span to the right.\n",
      "        \n",
      "        colspan : int\n",
      "            Number of columns for the axis to span downwards.\n",
      "        \n",
      "        fig : `Figure`, optional\n",
      "            Figure to place axis in. Defaults to current figure.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional keyword arguments are handed to `add_subplot`.\n",
      "        \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The following call ::\n",
      "        \n",
      "            subplot2grid(shape, loc, rowspan=1, colspan=1)\n",
      "        \n",
      "        is identical to ::\n",
      "        \n",
      "            gridspec=GridSpec(shape[0], shape[1])\n",
      "            subplotspec=gridspec.new_subplotspec(loc, rowspan, colspan)\n",
      "            subplot(subplotspec)\n",
      "    \n",
      "    subplot_tool(targetfig=None)\n",
      "        Launch a subplot tool window for a figure.\n",
      "        \n",
      "        A :class:`matplotlib.widgets.SubplotTool` instance is returned.\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, optional, 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\n",
      "                  subplots.\n",
      "                - False or 'none': each subplot x- or y-axis will be\n",
      "                  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 visible.  Similarly, when subplots\n",
      "            have a shared y-axis along a row, only the y tick labels of the first\n",
      "            column subplot are visible.\n",
      "        \n",
      "        squeeze : bool, optional, default: True\n",
      "            - If True, extra dimensions are squeezed out from the returned Axes\n",
      "              object:\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 1xN subplots, the returned object is a 1D numpy\n",
      "                  object array of Axes objects are returned as numpy 1D arrays.\n",
      "                - for NxM, subplots with N>1 and M>1 are returned as a 2D arrays.\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",
      "            :meth:`~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\n",
      "            :class:`~matplotlib.gridspec.GridSpec` constructor used to create the\n",
      "            grid the subplots are placed on.\n",
      "        \n",
      "        **fig_kw :\n",
      "            All additional keyword arguments are passed to the :func:`figure` call.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        fig : :class:`matplotlib.figure.Figure` object\n",
      "        \n",
      "        ax : Axes object or array of Axes objects.\n",
      "        \n",
      "            ax can be either a single :class:`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",
      "        Examples\n",
      "        --------\n",
      "        First create some toy data:\n",
      "        \n",
      "        >>> x = np.linspace(0, 2*np.pi, 400)\n",
      "        >>> y = np.sin(x**2)\n",
      "        \n",
      "        Creates just a figure and only one subplot\n",
      "        \n",
      "        >>> fig, ax = plt.subplots()\n",
      "        >>> ax.plot(x, y)\n",
      "        >>> ax.set_title('Simple plot')\n",
      "        \n",
      "        Creates two subplots and unpacks the output array immediately\n",
      "        \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",
      "        Creates four polar axes, and accesses them through the returned array\n",
      "        \n",
      "        >>> fig, axes = plt.subplots(2, 2, subplot_kw=dict(polar=True))\n",
      "        >>> axes[0, 0].plot(x, y)\n",
      "        >>> axes[1, 1].scatter(x, y)\n",
      "        \n",
      "        Share a X axis with each column of subplots\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharex='col')\n",
      "        \n",
      "        Share a Y axis with each row of subplots\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharey='row')\n",
      "        \n",
      "        Share both X and Y axes with all subplots\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharex='all', sharey='all')\n",
      "        \n",
      "        Note that this is the same as\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharex=True, sharey=True)\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        figure\n",
      "        subplot\n",
      "    \n",
      "    subplots_adjust(*args, **kwargs)\n",
      "        Tune the subplot layout.\n",
      "        \n",
      "        call signature::\n",
      "        \n",
      "          subplots_adjust(left=None, bottom=None, right=None, top=None,\n",
      "                          wspace=None, hspace=None)\n",
      "        \n",
      "        The parameter meanings (and suggested defaults) are::\n",
      "        \n",
      "          left  = 0.125  # the left side of the subplots of the figure\n",
      "          right = 0.9    # the right side of the subplots of the figure\n",
      "          bottom = 0.1   # the bottom of the subplots of the figure\n",
      "          top = 0.9      # the top of the subplots of the figure\n",
      "          wspace = 0.2   # the amount of width reserved for space between subplots,\n",
      "                         # expressed as a fraction of the average axis width\n",
      "          hspace = 0.2   # the amount of height reserved for space between subplots,\n",
      "                         # expressed as a fraction of the average axis height\n",
      "        \n",
      "        The actual defaults are controlled by the rc file\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(*args, **kwargs)\n",
      "        Add a centered title to the figure.\n",
      "        \n",
      "        kwargs are :class:`matplotlib.text.Text` properties.  Using figure\n",
      "        coordinates, the defaults are:\n",
      "        \n",
      "          x : 0.5\n",
      "            The x location of the text in figure coords\n",
      "        \n",
      "          y : 0.98\n",
      "            The y location of the text in figure coords\n",
      "        \n",
      "          horizontalalignment : 'center'\n",
      "            The horizontal alignment of the text\n",
      "        \n",
      "          verticalalignment : 'top'\n",
      "            The vertical alignment of the text\n",
      "        \n",
      "        If the `fontproperties` keyword argument is given then the\n",
      "        rcParams defaults for `fontsize` (`figure.titlesize`) and\n",
      "        `fontweight` (`figure.titleweight`) will be ignored in favour\n",
      "        of the `FontProperties` defaults.\n",
      "        \n",
      "        A :class:`matplotlib.text.Text` instance is returned.\n",
      "        \n",
      "        Example::\n",
      "        \n",
      "          fig.suptitle('this is the figure title', fontsize=12)\n",
      "    \n",
      "    switch_backend(newbackend)\n",
      "        Switch the default backend.  This feature is **experimental**, and\n",
      "        is only expected to work switching to an image backend.  e.g., if\n",
      "        you have a bunch of PostScript scripts that you want to run from\n",
      "        an interactive ipython session, you may want to switch to the PS\n",
      "        backend before running them to avoid having a bunch of GUI windows\n",
      "        popup.  If you try to interactively switch from one GUI backend to\n",
      "        another, you will explode.\n",
      "        \n",
      "        Calling this command will close all open windows.\n",
      "    \n",
      "    table(**kwargs)\n",
      "        Add a table to the current axes.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          table(cellText=None, cellColours=None,\n",
      "                cellLoc='right', colWidths=None,\n",
      "                rowLabels=None, rowColours=None, rowLoc='left',\n",
      "                colLabels=None, colColours=None, colLoc='center',\n",
      "                loc='bottom', bbox=None)\n",
      "        \n",
      "        Returns a :class:`matplotlib.table.Table` instance. Either `cellText`\n",
      "        or `cellColours` must be provided. For finer grained control over\n",
      "        tables, use the :class:`~matplotlib.table.Table` class and add it to\n",
      "        the axes with :meth:`~matplotlib.axes.Axes.add_table`.\n",
      "        \n",
      "        Thanks to John Gill for providing the class and table.\n",
      "        \n",
      "        kwargs control the :class:`~matplotlib.table.Table`\n",
      "        properties:\n",
      "        \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: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          clip_box: a `.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "          contains: a callable function \n",
      "          figure: a `.Figure` instance \n",
      "          fontsize: a float in points \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          path_effects: `.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float\n",
      "    \n",
      "    text(x, y, s, fontdict=None, withdash=False, **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 : scalars\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 : dictionary, optional, default: None\n",
      "            A dictionary to override the default text properties. If fontdict\n",
      "            is None, the defaults are determined by your rc parameters.\n",
      "        \n",
      "        withdash : boolean, optional, default: False\n",
      "            Creates a `~matplotlib.text.TextWithDash` instance instead of a\n",
      "            `~matplotlib.text.Text` instance.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        text : `.Text`\n",
      "            The created `.Text` instance.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.text.Text` properties.\n",
      "            Other miscellaneous text parameters.\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(*args, **kwargs)\n",
      "        Get or set the theta locations of the gridlines in a polar plot.\n",
      "        \n",
      "        If no arguments are passed, return a tuple (*lines*, *labels*)\n",
      "        where *lines* is an array of radial gridlines\n",
      "        (:class:`~matplotlib.lines.Line2D` instances) and *labels* is an\n",
      "        array of tick labels (:class:`~matplotlib.text.Text` instances)::\n",
      "        \n",
      "          lines, labels = thetagrids()\n",
      "        \n",
      "        Otherwise the syntax is::\n",
      "        \n",
      "          lines, labels = thetagrids(angles, labels=None, fmt='%d', frac = 1.1)\n",
      "        \n",
      "        set the angles at which to place the theta grids (these gridlines\n",
      "        are equal along the theta dimension).\n",
      "        \n",
      "        *angles* is in degrees.\n",
      "        \n",
      "        *labels*, if not *None*, is a len(angles) list of strings of the\n",
      "        labels to use at each angle.\n",
      "        \n",
      "        If *labels* is *None*, the labels will be ``fmt%angle``.\n",
      "        \n",
      "        *frac* is the fraction of the polar axes radius at which to place\n",
      "        the label (1 is the edge). e.g., 1.05 is outside the axes and 0.95\n",
      "        is inside the axes.\n",
      "        \n",
      "        Return value is a list of tuples (*lines*, *labels*):\n",
      "        \n",
      "          - *lines* are :class:`~matplotlib.lines.Line2D` instances\n",
      "        \n",
      "          - *labels* are :class:`~matplotlib.text.Text` instances.\n",
      "        \n",
      "        Note that on input, the *labels* argument is a list of strings,\n",
      "        and on output it is a list of :class:`~matplotlib.text.Text`\n",
      "        instances.\n",
      "        \n",
      "        Examples::\n",
      "        \n",
      "          # set the locations of the radial gridlines and labels\n",
      "          lines, labels = thetagrids( range(45,360,90) )\n",
      "        \n",
      "          # set the locations and labels of the radial gridlines and labels\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",
      "        Parameters\n",
      "        ----------\n",
      "        axis : {'x', 'y', 'both'}, optional\n",
      "            Which axis to apply the parameters to.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        axis : {'x', 'y', 'both'}\n",
      "            Axis on which to operate; default is 'both'.\n",
      "        \n",
      "        reset : bool\n",
      "            If *True*, set all parameters to defaults\n",
      "            before processing other keyword arguments.  Default is\n",
      "            *False*.\n",
      "        \n",
      "        which : {'major', 'minor', 'both'}\n",
      "            Default is 'major'; apply arguments to *which* ticks.\n",
      "        \n",
      "        direction : {'in', 'out', 'inout'}\n",
      "            Puts ticks inside the axes, outside the axes, or both.\n",
      "        \n",
      "        length : float\n",
      "            Tick length in points.\n",
      "        \n",
      "        width : float\n",
      "            Tick width in points.\n",
      "        \n",
      "        color : color\n",
      "            Tick color; accepts any mpl color spec.\n",
      "        \n",
      "        pad : float\n",
      "            Distance in points between tick and label.\n",
      "        \n",
      "        labelsize : float or str\n",
      "            Tick label font size in points or as a string (e.g., 'large').\n",
      "        \n",
      "        labelcolor : color\n",
      "            Tick label color; mpl color spec.\n",
      "        \n",
      "        colors : color\n",
      "            Changes the tick color and the label color to the same value:\n",
      "            mpl color spec.\n",
      "        \n",
      "        zorder : float\n",
      "            Tick and label zorder.\n",
      "        \n",
      "        bottom, top, left, right : bool\n",
      "            Whether to draw the respective ticks.\n",
      "        \n",
      "        labelbottom, labeltop, labelleft, labelright : bool\n",
      "            Whether to draw the respective tick labels.\n",
      "        \n",
      "        labelrotation : float\n",
      "            Tick label rotation\n",
      "        \n",
      "        grid_color : color\n",
      "            Changes the gridline color to the given mpl color spec.\n",
      "        \n",
      "        grid_alpha : float\n",
      "            Transparency of gridlines: 0 (transparent) to 1 (opaque).\n",
      "        \n",
      "        grid_linewidth : float\n",
      "            Width of gridlines in points.\n",
      "        \n",
      "        grid_linestyle : string\n",
      "            Any valid :class:`~matplotlib.lines.Line2D` line style spec.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        Usage ::\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(**kwargs)\n",
      "        Change the `~matplotlib.ticker.ScalarFormatter` used by\n",
      "        default for linear axes.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          ==============   =========================================\n",
      "          Keyword          Description\n",
      "          ==============   =========================================\n",
      "          *style*          [ 'sci' (or 'scientific') | 'plain' ]\n",
      "                           plain turns off scientific notation\n",
      "          *scilimits*      (m, n), pair of integers; if *style*\n",
      "                           is 'sci', scientific notation will\n",
      "                           be used for numbers outside the range\n",
      "                           10`m`:sup: to 10`n`:sup:.\n",
      "                           Use (0,0) to include all numbers.\n",
      "          *useOffset*      [ bool | offset ]; if True,\n",
      "                           the offset will be calculated as needed;\n",
      "                           if False, no offset will be used; if a\n",
      "                           numeric offset is specified, it will be\n",
      "                           used.\n",
      "          *axis*           [ 'x' | 'y' | 'both' ]\n",
      "          *useLocale*      If True, format the number according to\n",
      "                           the current locale.  This affects things\n",
      "                           such as the character used for the\n",
      "                           decimal separator.  If False, use\n",
      "                           C-style (English) formatting.  The\n",
      "                           default setting is controlled by the\n",
      "                           axes.formatter.use_locale rcparam.\n",
      "          *useMathText*    If True, render the offset and scientific\n",
      "                           notation in mathtext\n",
      "          ==============   =========================================\n",
      "        \n",
      "        Only the major ticks are affected.\n",
      "        If the method is called when the\n",
      "        :class:`~matplotlib.ticker.ScalarFormatter` is not the\n",
      "        :class:`~matplotlib.ticker.Formatter` being used, an\n",
      "        :exc:`AttributeError` will be raised.\n",
      "    \n",
      "    tight_layout(pad=1.08, h_pad=None, w_pad=None, rect=None)\n",
      "        Automatically adjust subplot parameters to give specified padding.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        pad : float\n",
      "            padding between the figure edge and the edges of subplots, as a fraction of the font-size.\n",
      "        h_pad, w_pad : float\n",
      "            padding (height/width) between edges of adjacent subplots.\n",
      "            Defaults to `pad_inches`.\n",
      "        rect : if rect is given, it is interpreted as a rectangle\n",
      "            (left, bottom, right, top) in the normalized figure\n",
      "            coordinate that the whole subplots area (including\n",
      "            labels) will fit into. Default is (0, 0, 1, 1).\n",
      "    \n",
      "    title(s, *args, **kwargs)\n",
      "        Set a title of the current axes.\n",
      "        \n",
      "        Set one of the three available axes titles. The available titles are\n",
      "        positioned above the axes in the center, flush with the left edge,\n",
      "        and flush with the right edge.\n",
      "        \n",
      "        .. seealso::\n",
      "            See :func:`~matplotlib.pyplot.text` for adding text\n",
      "            to the current axes\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",
      "                'verticalalignment': 'baseline',\n",
      "                'horizontalalignment': loc}\n",
      "        \n",
      "        loc : {'center', 'left', 'right'}, str, optional\n",
      "            Which title to set, defaults to 'center'\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        text : :class:`~matplotlib.text.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\n",
      "            :class:`~matplotlib.text.Text` for a list of valid text\n",
      "            properties.\n",
      "    \n",
      "    tricontour(*args, **kwargs)\n",
      "        Draw contours on an unstructured triangular grid.\n",
      "        :func:`~matplotlib.pyplot.tricontour` and\n",
      "        :func:`~matplotlib.pyplot.tricontourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either::\n",
      "        \n",
      "            tricontour(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        object, or\n",
      "        \n",
      "        ::\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\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of\n",
      "        these possibilities.\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\n",
      "        in the triangulation.  The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(..., Z, N)\n",
      "        \n",
      "        contour up to *N+1* automatically chosen contour levels\n",
      "        (*N* intervals).\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(..., Z, V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontourf(..., Z, V)\n",
      "        \n",
      "        fill the (len(*V*)-1) regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        ``C = tricontour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.TriContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "            *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "            *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "            *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "            *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "            *levels* [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "            *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "            *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "            *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is None, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "            *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "            *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        \n",
      "        tricontour-only keyword arguments:\n",
      "        \n",
      "            *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified\n",
      "        \n",
      "            *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the 'solid' is used.\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",
      "            If contour is using a monochrome colormap and the contour\n",
      "            level is less than 0, then the linestyle specified\n",
      "            in ``contour.negative_linestyle`` in ``matplotlibrc``\n",
      "            will be used.\n",
      "        \n",
      "        tricontourf-only keyword arguments:\n",
      "        \n",
      "            *antialiased*: bool\n",
      "            enable antialiasing\n",
      "        \n",
      "        Note: tricontourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    tricontourf(*args, **kwargs)\n",
      "        Draw contours on an unstructured triangular grid.\n",
      "        :func:`~matplotlib.pyplot.tricontour` and\n",
      "        :func:`~matplotlib.pyplot.tricontourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either::\n",
      "        \n",
      "            tricontour(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        object, or\n",
      "        \n",
      "        ::\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\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of\n",
      "        these possibilities.\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\n",
      "        in the triangulation.  The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(..., Z, N)\n",
      "        \n",
      "        contour up to *N+1* automatically chosen contour levels\n",
      "        (*N* intervals).\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(..., Z, V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontourf(..., Z, V)\n",
      "        \n",
      "        fill the (len(*V*)-1) regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            tricontour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        ``C = tricontour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.TriContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "            *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "            *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "            *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "            *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "            *levels* [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "            *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "            *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "            *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is None, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "            *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "            *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        \n",
      "        tricontour-only keyword arguments:\n",
      "        \n",
      "            *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified\n",
      "        \n",
      "            *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the 'solid' is used.\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",
      "            If contour is using a monochrome colormap and the contour\n",
      "            level is less than 0, then the linestyle specified\n",
      "            in ``contour.negative_linestyle`` in ``matplotlibrc``\n",
      "            will be used.\n",
      "        \n",
      "        tricontourf-only keyword arguments:\n",
      "        \n",
      "            *antialiased*: bool\n",
      "            enable antialiasing\n",
      "        \n",
      "        Note: tricontourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    tripcolor(*args, **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 :class:`matplotlib.tri.Triangulation`\n",
      "        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\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of these\n",
      "        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\n",
      "        :meth:`~matplotlib.axes.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;\n",
      "        either::\n",
      "        \n",
      "          triplot(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        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\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of these\n",
      "        possibilities.\n",
      "        \n",
      "        The remaining args and kwargs are the same as for\n",
      "        :meth:`~matplotlib.axes.Axes.plot`.\n",
      "        \n",
      "        Return a list of 2 :class:`~matplotlib.lines.Line2D` containing\n",
      "        respectively:\n",
      "        \n",
      "            - the lines plotted for triangles edges\n",
      "            - the markers plotted for triangles nodes\n",
      "    \n",
      "    twinx(ax=None)\n",
      "        Make a second axes that shares the *x*-axis.  The new axes will\n",
      "        overlay *ax* (or the current axes if *ax* is *None*).  The ticks\n",
      "        for *ax2* will be placed on the right, and the *ax2* instance is\n",
      "        returned.\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "           :file:`examples/api_examples/two_scales.py`\n",
      "              For an example\n",
      "    \n",
      "    twiny(ax=None)\n",
      "        Make a second axes that shares the *y*-axis.  The new axis will\n",
      "        overlay *ax* (or the current axes if *ax* is *None*).  The ticks\n",
      "        for *ax2* will be placed on the top, and the *ax2* instance is\n",
      "        returned.\n",
      "    \n",
      "    uninstall_repl_displayhook()\n",
      "        Uninstalls 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, points=100, bw_method=None, hold=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, and the maximum.\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",
      "          Sets 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",
      "        points : scalar, 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",
      "        \n",
      "        result : 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\n",
      "              :class:`matplotlib.collections.PolyCollection` instances\n",
      "              containing the filled area of each violin.\n",
      "        \n",
      "            - ``cmeans``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the mean values of each of the\n",
      "              violin's distribution.\n",
      "        \n",
      "            - ``cmins``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the bottom of each violin's\n",
      "              distribution.\n",
      "        \n",
      "            - ``cmaxes``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the top of each violin's\n",
      "              distribution.\n",
      "        \n",
      "            - ``cbars``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the centers of each violin's\n",
      "              distribution.\n",
      "        \n",
      "            - ``cmedians``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the median values of each of the\n",
      "              violin's distribution.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. [Notes section required for data comment. See #10189.]\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'dataset'.\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='k', linestyles='solid', label='', hold=None, data=None, **kwargs)\n",
      "        Plot vertical lines.\n",
      "        \n",
      "        Plot vertical lines at each *x* from *ymin* to *ymax*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : scalar or 1D array_like\n",
      "            x-indexes where to plot the lines.\n",
      "        \n",
      "        ymin, ymax : scalar or 1D array_like\n",
      "            Respective beginning and end of each line. If scalars are\n",
      "            provided, all lines will have same length.\n",
      "        \n",
      "        colors : array_like of colors, optional, default: 'k'\n",
      "        \n",
      "        linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional\n",
      "        \n",
      "        label : string, optional, default: ''\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : `~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",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'x', 'ymax', 'ymin'.\n",
      "    \n",
      "    waitforbuttonpress(*args, **kwargs)\n",
      "        Blocking call to interact with the figure.\n",
      "        \n",
      "        This will return True is a key was pressed, False if a mouse\n",
      "        button was pressed and None if *timeout* was reached without\n",
      "        either being pressed.\n",
      "        \n",
      "        If *timeout* is negative, does not 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 0x7f21a053a0d0>, usevlines=True, maxlags=10, hold=None, data=None, **kwargs)\n",
      "        Plot the cross correlation between *x* and *y*.\n",
      "        \n",
      "        The correlation with lag k is defined as sum_n x[n+k] * conj(y[n]).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : sequence of scalars of length n\n",
      "        \n",
      "        y : sequence of scalars of length n\n",
      "        \n",
      "        hold : bool, optional, *deprecated*, default: True\n",
      "        \n",
      "        detrend : callable, optional, default: `mlab.detrend_none`\n",
      "            *x* is detrended by the *detrend* callable. Default is no\n",
      "            normalization.\n",
      "        \n",
      "        normed : bool, optional, default: True\n",
      "            If ``True``, input vectors are normalised to unit length.\n",
      "        \n",
      "        usevlines : bool, optional, default: True\n",
      "            If ``True``, `Axes.vlines` is used to plot the vertical lines from\n",
      "            the origin to the acorr. Otherwise, `Axes.plot` is used.\n",
      "        \n",
      "        maxlags : int, optional\n",
      "            Number of lags to show. If None, will return all ``2 * len(x) - 1``\n",
      "            lags. Default is 10.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lags : array (lenth ``2*maxlags+1``)\n",
      "            lag vector.\n",
      "        c : array  (length ``2*maxlags+1``)\n",
      "            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 : `~matplotlib.lines.Line2D` property, optional\n",
      "            Only used if usevlines is ``False``.\n",
      "        \n",
      "        marker : string, optional\n",
      "            Default is 'o'.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cross correlation is performed with :func:`numpy.correlate` with\n",
      "        ``mode = 2``.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    xkcd(scale=1, length=100, randomness=2)\n",
      "        Turns on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.\n",
      "        This will only have effect on things drawn after this function is\n",
      "        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(s, *args, **kwargs)\n",
      "        Set the x-axis label of the current axes.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            xlabel(label, fontdict=None, labelpad=None, **kwargs)\n",
      "        \n",
      "        This is the pyplot equivalent of calling `.set_xlabel` on the current axes.\n",
      "        See there for a full parameter description.\n",
      "    \n",
      "    xlim(*args, **kwargs)\n",
      "        Get or set the x limits of the current axes.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            xmin, xmax = xlim()  # return the current xlim\n",
      "            xlim((xmin, xmax))   # set the xlim to xmin, xmax\n",
      "            xlim(xmin, xmax)     # set the xlim to xmin, xmax\n",
      "        \n",
      "        If you do not specify args, you can pass *xmin* or *xmax* as kwargs, i.e.::\n",
      "        \n",
      "            xlim(xmax=3)  # adjust the max leaving min unchanged\n",
      "            xlim(xmin=1)  # adjust the min leaving max unchanged\n",
      "        \n",
      "        Setting limits turns autoscaling off for the x-axis.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xmin, xmax\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(*args, **kwargs)\n",
      "        Set the scaling of the x-axis.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            xscale(scale, **kwargs)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        scale : ['linear' | 'log' | 'logit' | 'symlog']\n",
      "            The scaling type.\n",
      "        **kwargs\n",
      "            Additional parameters depend on *scale*. See Notes.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This is the pyplot equivalent of calling `~.Axes.set_xscale` on the\n",
      "        current axes.\n",
      "        \n",
      "        Different keywords may be accepted, depending on the scale:\n",
      "        \n",
      "            'linear'\n",
      "        \n",
      "                \n",
      "        \n",
      "        \n",
      "            'log'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *nonposx*/*nonposy*: ['mask' | 'clip' ]\n",
      "                  non-positive values in *x* or *y* can be masked as\n",
      "                  invalid, or clipped to a very small positive number\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "        \n",
      "        \n",
      "            'logit'\n",
      "        \n",
      "                *nonpos*: ['mask' | 'clip' ]\n",
      "                  values beyond ]0, 1[ can be masked as invalid, or clipped to a number\n",
      "                  very close to 0 or 1\n",
      "        \n",
      "        \n",
      "            'symlog'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *linthreshx*/*linthreshy*:\n",
      "                  A single float which defines the range (-*x*, *x*), within\n",
      "                  which the plot is linear. This avoids having the plot go to\n",
      "                  infinity around zero.\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "                \n",
      "                *linscalex*/*linscaley*:\n",
      "                   This allows the linear range (-*linthresh* to *linthresh*)\n",
      "                   to be stretched relative to the logarithmic range.  Its\n",
      "                   value is the number of decades to use for each half of the\n",
      "                   linear range.  For example, when *linscale* == 1.0 (the\n",
      "                   default), the space used for the positive and negative\n",
      "                   halves of the linear range will be equal to one decade in\n",
      "                   the logarithmic range.\n",
      "    \n",
      "    xticks(*args, **kwargs)\n",
      "        Get or set the current tick locations and labels of the x-axis.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            locs, labels = xticks()           # Get locations and labels\n",
      "        \n",
      "            xticks(locs, [labels], **kwargs)  # Set locations and labels\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        locs : array_like\n",
      "            A list of positions at which ticks should be placed. You can pass an\n",
      "            empty list to disable xticks.\n",
      "        \n",
      "        labels : array_like, optional\n",
      "            A list of explicit labels to place at the given *locs*.\n",
      "        \n",
      "        **kwargs\n",
      "            :class:`.Text` properties can be used to control the appearance of\n",
      "            the labels.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        locs\n",
      "            An array of label locations.\n",
      "        labels\n",
      "            A list of `.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",
      "        Get the current locations and labels:\n",
      "        \n",
      "            >>> locs, labels = xticks()\n",
      "        \n",
      "        Set label locations:\n",
      "        \n",
      "            >>> xticks(np.arange(0, 1, step=0.2))\n",
      "        \n",
      "        Set text labels:\n",
      "        \n",
      "            >>> xticks(np.arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue'))\n",
      "        \n",
      "        Set text labels and properties:\n",
      "        \n",
      "            >>> xticks(np.arange(12), calendar.month_name[1:13], rotation=20)\n",
      "        \n",
      "        Disable xticks:\n",
      "        \n",
      "            >>> xticks([])\n",
      "    \n",
      "    ylabel(s, *args, **kwargs)\n",
      "        Set the y-axis label of the current axes.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            ylabel(label, fontdict=None, labelpad=None, **kwargs)\n",
      "        \n",
      "        This is the pyplot equivalent of calling `.set_ylabel` on the current axes.\n",
      "        See there for a full parameter description.\n",
      "    \n",
      "    ylim(*args, **kwargs)\n",
      "        Get or set the y-limits of the current axes.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            ymin, ymax = ylim()  # return the current ylim\n",
      "            ylim((ymin, ymax))   # set the ylim to ymin, ymax\n",
      "            ylim(ymin, ymax)     # set the ylim to ymin, ymax\n",
      "        \n",
      "        If you do not specify args, you can alternatively pass *ymin* or *ymax* as\n",
      "        kwargs, i.e.::\n",
      "        \n",
      "            ylim(ymax=3)  # adjust the max leaving min unchanged\n",
      "            ylim(ymin=1)  # adjust the min leaving max unchanged\n",
      "        \n",
      "        Setting limits turns autoscaling off for the y-axis.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        ymin, ymax\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(*args, **kwargs)\n",
      "        Set the scaling of the y-axis.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "            yscale(scale, **kwargs)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        scale : ['linear' | 'log' | 'logit' | 'symlog']\n",
      "            The scaling type.\n",
      "        **kwargs\n",
      "            Additional parameters depend on *scale*. See Notes.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This is the pyplot equivalent of calling `~.Axes.set_yscale` on the\n",
      "        current axes.\n",
      "        \n",
      "        Different keywords may be accepted, depending on the scale:\n",
      "        \n",
      "            'linear'\n",
      "        \n",
      "                \n",
      "        \n",
      "        \n",
      "            'log'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *nonposx*/*nonposy*: ['mask' | 'clip' ]\n",
      "                  non-positive values in *x* or *y* can be masked as\n",
      "                  invalid, or clipped to a very small positive number\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "        \n",
      "        \n",
      "            'logit'\n",
      "        \n",
      "                *nonpos*: ['mask' | 'clip' ]\n",
      "                  values beyond ]0, 1[ can be masked as invalid, or clipped to a number\n",
      "                  very close to 0 or 1\n",
      "        \n",
      "        \n",
      "            'symlog'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *linthreshx*/*linthreshy*:\n",
      "                  A single float which defines the range (-*x*, *x*), within\n",
      "                  which the plot is linear. This avoids having the plot go to\n",
      "                  infinity around zero.\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "                \n",
      "                *linscalex*/*linscaley*:\n",
      "                   This allows the linear range (-*linthresh* to *linthresh*)\n",
      "                   to be stretched relative to the logarithmic range.  Its\n",
      "                   value is the number of decades to use for each half of the\n",
      "                   linear range.  For example, when *linscale* == 1.0 (the\n",
      "                   default), the space used for the positive and negative\n",
      "                   halves of the linear range will be equal to one decade in\n",
      "                   the logarithmic range.\n",
      "    \n",
      "    yticks(*args, **kwargs)\n",
      "        Get or set the current tick locations and labels of the y-axis.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            locs, labels = yticks()           # Get locations and labels\n",
      "        \n",
      "            yticks(locs, [labels], **kwargs)  # Set locations and labels\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        locs : array_like\n",
      "            A list of positions at which ticks should be placed. You can pass an\n",
      "            empty list to disable yticks.\n",
      "        \n",
      "        labels : array_like, optional\n",
      "            A list of explicit labels to place at the given *locs*.\n",
      "        \n",
      "        **kwargs\n",
      "            :class:`.Text` properties can be used to control the appearance of\n",
      "            the labels.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        locs\n",
      "            An array of label locations.\n",
      "        labels\n",
      "            A list of `.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",
      "        Get the current locations and labels:\n",
      "        \n",
      "            >>> locs, labels = yticks()\n",
      "        \n",
      "        Set label locations:\n",
      "        \n",
      "            >>> yticks(np.arange(0, 1, step=0.2))\n",
      "        \n",
      "        Set text labels:\n",
      "        \n",
      "            >>> yticks(np.arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue'))\n",
      "        \n",
      "        Set text labels and properties:\n",
      "        \n",
      "            >>> yticks(np.arange(12), calendar.month_name[1:13], rotation=45)\n",
      "        \n",
      "        Disable yticks:\n",
      "        \n",
      "            >>> yticks([])\n",
      "\n",
      "DATA\n",
      "    absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...\n",
      "    division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192...\n",
      "    print_function = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0)...\n",
      "    rcParams = RcParams({'_internal.classic_mode': False,\n",
      "         ...nor.widt...\n",
      "    rcParamsDefault = RcParams({'_internal.classic_mode': False,\n",
      "         ...n...\n",
      "    unicode_literals = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', ...\n",
      "\n",
      "FILE\n",
      "    /home/rtse/anaconda3/envs/b3s/lib/python3.6/site-packages/matplotlib/pyplot.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}