OwlCyberSecurity - MANAGER
Edit File: _axes.cpython-38.pyc
U ��]�� � @ s� d dl Zd dlZd dlZd dlZd dlZd dlZd dlmZ d dl Z d dl m Z d dl m Z mZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dl m Z d dl m Z d dl m!Z" d dl#m$Z% d dl&m'Z( d dl)m*Z+ d dl,m-Z- d dl.m/Z0 d dl1m2Z3 d dl4m5Z6 d dl7m8Z9 d dl:m;Z< d dl=m>Z? d dl@mAZB d dlCmDZE d dlFmGZH d dlImJZK d dlLmMZMmNZNmOZO d dlPmQZQmRZR d dlSmTZT zd dlUmVZV W n eWk �r� dd d �ZVY nX e�XeY�ZZd d � Z[G d d� deQ�Z\dS )� N)�Number)�ma)�_preprocess_data�rcParams)� BarContainer�ErrorbarContainer� StemContainer)� _AxesBase�_process_plot_format)� SecondaryAxis)�histogram_bin_edgesc C sp t �|�dkr|S t|t�r0t �| |||�d S |d kr<d}|d krXt �| �t �| �f}t j||d f�� S d S )N� � )�np�ndim� isinstance�str� histogram�min�max�linspace)Zarr�bins�range�weights� r �7/usr/lib/python3/dist-packages/matplotlib/axes/_axes.pyr + s r c s( t jj| � � |�|�� ��fdd�}|S )a� Helper function to locate inset axes, used in `.Axes.inset_axes`. A locator gets used in `Axes.set_aspect` to override the default locations... It is a function that takes an axes object and a renderer and tells `set_aspect` where it is to be placed. Here *rect* is a rectangle [l, b, w, h] that specifies the location for the axes in the transform given by *trans* on the *parent*. c s, � }t �|��}�jj�� }t �||�}|S �N)� mtransformsZTransformedBbox�figure� transFigure�inverted)ZaxZrendererZbbox�bbZtr�Z_boundsZ_parentZ_transr r � inset_locatorS s z*_make_inset_locator.<locals>.inset_locator)r �Bbox� from_bounds)�bounds�trans�parentr# r r" r �_make_inset_locatorB s r) c @ s� e Zd ZdZe�d�edd� ��Zd�dd�Zd�d d �Z d d � Z d�d d�Z dd� Z d�dd�Z d�dd�Zejdd� �Zdd� Zddd�dd �Zd�dd d d d d!�d"d#�Zd$d%� Zejdd&�d'd(��Zdd&�d)d*�Ze�dd+�d�d-d.��Zejd/d0� �Zej j je_ejd�d3d4��Z ejd�d5d6��Z ejd�d7d8��Z d�d9d:�Z!e"d;d<d=d>gd;d?�d�dCdD��Z#e"dEdFdGd>gdEd?�d�dHdI��Z$e"dJdKdLdMd>dNgdO�ejd�dQdR���Z%ejdSdSddT�dUdV��Z&e"dEd;gd;d?�ejd�dXdY���Z'ejdZd[� �Z(ejd\d]� �Z)ejd^d_� �Z*e"dEgdEd?�d`da� �Z+e"dEd;gd;d?�dSe,j-dSdbfdcdd��Z.deddf�dgdh�Z/e0didj� �Z1e"� ejd�ddl�dmdn���Z2ejd�ddl�dodp��Z3e"� ejdqdr� ��Z4e"� dddd1dd,ds�dtdu��Z5e"dEdvdwd>gdO�d�d{d|��Z6e"dEd;d}d~gd;d?�ejd�dd����Z7e�8dd�d��e"� �d d�d����Z9e�8dd�d���dd�d���Z:e0d�d�� �Z;e"dEd;d�dMd�d�d�d�d�g d;d?��dd,d��d�d���Z<e"dEd;gd;d?�ejdd�dd�d�dddddddd�e=j>dd,fd�d����Z?ejd�d�� �Z@d�d�� ZAeBjCjDeA_d�d�� ZEe"� d�d�� �ZFeBjGjHeF_e"� ejd�d�� ��ZIdd��d�d��ZJe"dEd�d�d�gdO�ej�dd�d����ZKe"d;d�d�d�gdO�ej�dd�d����ZLe"� e�dd��e�dd���dd�d�����ZMe0d,d��d�d���ZNe"� ejdddddd��d�d����ZOe"� ejdddddd�d,d��d�d����ZPe"� ejdddddd��d�d����ZQe"� d�d�� �ZReSjTjUeR_e"� d�d�� �ZVeSjTjUeV_d�dÄ ZWeSjXjWjeW_e"dEd�gdEd?��dd�dɄ�ZYe"dEd;d�gdO�e�8dd�dˡ�dd�d̈́��ZZe"dEgdO�ej�dd�dτ��Z[e"dEd;gd;d?�ej�d d�dф��Z\e"dEgdO�ej�d d�dӄ��Z]e"dEgdO�ej�d d�dՄ��Z^e"dEgdO�ej�d d�dׄ��Z_e"dEd;gdO�ejd�d�d1e,j-e,j`d1dd�df d�d܄��Zae"dEgdO�ej�d d�dބ��Zbej�dd�d��Zcd�d� Zde"d�gdO��dd�d��Ze�dd�d�ZfegjhZhe"� eijj�Zje"dEd;d�d�d�gdO�ekjl�ZlemjnZnemjoZoemjpZpemjqZqdS ( �Axesa The :class:`Axes` contains most of the figure elements: :class:`~matplotlib.axis.Axis`, :class:`~matplotlib.axis.Tick`, :class:`~matplotlib.lines.Line2D`, :class:`~matplotlib.text.Text`, :class:`~matplotlib.patches.Polygon`, etc., and sets the coordinate system. The :class:`Axes` instance supports callbacks through a callbacks attribute which is a :class:`~matplotlib.cbook.CallbackRegistry` instance. The events you can connect to are 'xlim_changed' and 'ylim_changed' and the callback will be called with func(*ax*) where *ax* is the :class:`Axes` instance. Attributes ---------- dataLim : `.BBox` The bounding box enclosing all data displayed in the Axes. viewLim : `.BBox` The view limits in data coordinates. �3.1c C s dS )Nr* r ��selfr r r �anamey s z Axes.aname�centerc C sH z | j | j| jd�|�� }W n tk r> td| ��Y nX |�� S )a� Get an axes title. Get one of the three available axes titles. The available titles are positioned above the axes in the center, flush with the left edge, and flush with the right edge. Parameters ---------- loc : {'center', 'left', 'right'}, str, optional Which title to get, defaults to 'center'. Returns ------- title : str The title text string. ��leftr/ �right� '%s' is not a valid location)� _left_title�title� _right_title�lower�KeyError� ValueError�get_text)r- �locr5 r r r � get_title~ s ��zAxes.get_titleNc K s� z | j | j| jd�|�� }W n tk r> td| ��Y nX td td d|�� d�}|dkrjtd }| �t|�� |� |� |� |� |dk r�|� |� |� |� |S ) aG Set a title for the axes. Set one of the three available axes titles. The available titles are positioned above the axes in the center, flush with the left edge, and flush with the right edge. Parameters ---------- label : str Text to use for the title fontdict : dict A dictionary controlling the appearance of the title text, the default `fontdict` is:: {'fontsize': rcParams['axes.titlesize'], 'fontweight' : rcParams['axes.titleweight'], 'verticalalignment': 'baseline', 'horizontalalignment': loc} loc : {'center', 'left', 'right'}, str, optional Which title to set, defaults to 'center' pad : float The offset of the title from the top of the axes, in points. Default is ``None`` to use rcParams['axes.titlepad']. Returns ------- text : :class:`~matplotlib.text.Text` The matplotlib text instance representing the title Other Parameters ---------------- **kwargs : `~matplotlib.text.Text` properties Other keyword arguments are text properties, see :class:`~matplotlib.text.Text` for a list of valid text properties. r0 r3 zaxes.titlesizezaxes.titleweight�baseline)ZfontsizeZ fontweight�verticalalignment�horizontalalignmentNz axes.titlepad) r4 r5 r6 r7 r8 r9 r Z_set_title_offset_trans�floatZset_text�update)r- �label�fontdictr; Zpad�kwargsr5 �defaultr r r � set_title� s. *��� zAxes.set_titlec C s | j �� }|�� S )z- Get the xlabel text string. )�xaxis� get_labelr: �r- rB r r r � get_xlabel� s zAxes.get_xlabelc K s" |dk r|| j _| j j||f|�S )a+ Set the label for the x-axis. Parameters ---------- xlabel : str The label text. labelpad : scalar, optional, default: None Spacing in points from the axes bounding box including ticks and tick labels. Other Parameters ---------------- **kwargs : `.Text` properties `.Text` properties control the appearance of the label. See also -------- text : for information on how override and the optional args work N)rG �labelpad�set_label_text)r- ZxlabelrC rK rD r r r � set_xlabel� s zAxes.set_xlabelc C s | j �� }|�� S )z- Get the ylabel text string. )�yaxisrH r: rI r r r � get_ylabel� s zAxes.get_ylabelc K s" |dk r|| j _| j j||f|�S )a, Set the label for the y-axis. Parameters ---------- ylabel : str The label text. labelpad : scalar, optional, default: None Spacing in points from the axes bounding box including ticks and tick labels. Other Parameters ---------------- **kwargs : `.Text` properties `.Text` properties control the appearance of the label. See also -------- text : for information on how override and the optional args work N)rN rK rL )r- ZylabelrC rK rD r r r � set_ylabel s zAxes.set_ylabelc C s t �| g|�\}}||fS )z� Return handles and labels for legend ``ax.legend()`` is equivalent to :: h, l = ax.get_legend_handles_labels() ax.legend(h, l) )�mlegendZ_get_legend_handles_labels)r- Zlegend_handler_map�handles�labelsr r r �get_legend_handles_labels s �z Axes.get_legend_handles_labelsc O sP t j| gf|�|�\}}}}t|�r,td��t j| ||f|�| _| j| j_| jS )a� Place a legend on the axes. Call signatures:: legend() legend(labels) legend(handles, labels) The call signatures correspond to three different ways how to use this method. **1. Automatic detection of elements to be shown in the legend** The elements to be added to the legend are automatically determined, when you do not pass in any extra arguments. In this case, the labels are taken from the artist. You can specify them either at artist creation or by calling the :meth:`~.Artist.set_label` method on the artist:: line, = ax.plot([1, 2, 3], label='Inline label') ax.legend() or:: line, = ax.plot([1, 2, 3]) line.set_label('Label via method') ax.legend() Specific lines can be excluded from the automatic legend element selection by defining a label starting with an underscore. This is default for all artists, so calling `Axes.legend` without any arguments and without setting the labels manually will result in no legend being drawn. **2. Labeling existing plot elements** To make a legend for lines which already exist on the axes (via plot for instance), simply call this function with an iterable of strings, one for each legend item. For example:: ax.plot([1, 2, 3]) ax.legend(['A simple line']) Note: This way of using is discouraged, because the relation between plot elements and labels is only implicit by their order and can easily be mixed up. **3. Explicitly defining the elements in the legend** For full control of which artists have a legend entry, it is possible to pass an iterable of legend artists followed by an iterable of legend labels respectively:: legend((line1, line2, line3), ('label1', 'label2', 'label3')) Parameters ---------- handles : sequence of `.Artist`, optional A list of Artists (lines, patches) to be added to the legend. Use this together with *labels*, if you need full control on what is shown in the legend and the automatic mechanism described above is not sufficient. The length of handles and labels should be the same in this case. If they are not, they are truncated to the smaller length. labels : sequence of strings, optional A list of labels to show next to the artists. Use this together with *handles*, if you need full control on what is shown in the legend and the automatic mechanism described above is not sufficient. Other Parameters ---------------- %(_legend_kw_doc)s Returns ------- :class:`matplotlib.legend.Legend` instance Notes ----- Not all kinds of artist are supported by the legend command. See :doc:`/tutorials/intermediate/legend_guide` for details. Examples -------- .. plot:: gallery/text_labels_and_annotations/legend.py z-legend only accepts two non-keyword arguments)rQ Z_parse_legend_args�len� TypeErrorZLegend�legend_�_remove_legendZ_remove_method)r- �argsrD rR rS Z extra_argsr r r �legend+ s e��� z Axes.legendc C s d | _ d S r )rW )r- rZ r r r rX � s zAxes._remove_legend� )� transform�zorderc K sd |dkr| j }|�dd�}t||| �}|dd�}t| j|jf||d�|��}|�|� | �|� |S )a� Add a child inset axes to this existing axes. Warnings -------- This method is experimental as of 3.0, and the API may change. Parameters ---------- bounds : [x0, y0, width, height] Lower-left corner of inset axes, and its width and height. transform : `.Transform` Defaults to `ax.transAxes`, i.e. the units of *rect* are in axes-relative coordinates. zorder : number Defaults to 5 (same as `.Axes.legend`). Adjust higher or lower to change whether it is above or below data plotted on the parent axes. **kwargs Other *kwargs* are passed on to the `axes.Axes` child axes. Returns ------- Axes The created `.axes.Axes` instance. Examples -------- This example makes two inset axes, the first is in axes-relative coordinates, and the second in data-coordinates:: fig, ax = plt.subplots() ax.plot(range(10)) axin1 = ax.inset_axes([0.8, 0.1, 0.15, 0.15]) axin2 = ax.inset_axes( [5, 7, 2.3, 2.3], transform=ax.transData) NrB � inset_axes)r] rB )Z transAxes�popr) r* r r& Zset_axes_locator�add_child_axes) r- r& r\ r] rD rB r# r! �inset_axr r r r^ � s 0 �� zAxes.inset_axes�nonez0.5� �?g�(\��@)r\ � facecolor� edgecolor�alphar] c K s� | � � |dkr| j}|�dd�} |d |d f} tj| |d |d f||||| |d�|��} | �| � |dk �r�g } |d |d |d g} |d |d |d g}td�D ]\}td�D ]N}||f}| | || f}| tj||d d || d |||d � g7 } | �| d � q�q�|�� }|� | j j �}t j j|� � |�}|j|jk }|j|jk }|j|jk }|j|jk }| d �||A � | d �||k� | d �||k� | d �||A � | | fS )a� Add an inset indicator to the axes. This is a rectangle on the plot at the position indicated by *bounds* that optionally has lines that connect the rectangle to an inset axes (`.Axes.inset_axes`). Warnings -------- This method is experimental as of 3.0, and the API may change. Parameters ---------- bounds : [x0, y0, width, height] Lower-left corner of rectangle to be marked, and its width and height. inset_ax : `.Axes` An optional inset axes to draw connecting lines to. Two lines are drawn connecting the indicator box to the inset axes on corners chosen so as to not overlap with the indicator box. transform : `.Transform` Transform for the rectangle co-ordinates. Defaults to `ax.transAxes`, i.e. the units of *rect* are in axes-relative coordinates. facecolor : Matplotlib color Facecolor of the rectangle (default 'none'). edgecolor : Matplotlib color Color of the rectangle and color of the connecting lines. Default is '0.5'. alpha : number Transparency of the rectangle and connector lines. Default is 0.5. zorder : number Drawing order of the rectangle and connector lines. Default is 4.99 (just below the default level of inset axes). **kwargs Other *kwargs* are passed on to the rectangle patch. Returns ------- rectangle_patch : `.Patches.Rectangle` Rectangle artist. connector_lines : 4-tuple of `.Patches.ConnectionPatch` One for each of four connector lines. Two are set with visibility to *False*, but the user can set the visibility to True if the automatic choice is not deemed correct. NrB �indicate_insetr r � � )rd re rf r] rB r\ z axes fraction�data�-)ZaxesAZaxesBZ arrowstyler] re rf ���)Z apply_aspect� transDatar_ �mpatches� Rectangle� add_patchr ZConnectionPatchZ get_position� transformedr r r r$ r% �x0�x1�y0�y1Z set_visible)r- r& ra r\ rd re rf r] rD rB �xy� rectpatch�connects�xrZyrZxcZycZxyAZxyB�posZbboxinsZrectbboxrr rs rt ru r r r rg � sf @ �� � �� zAxes.indicate_insetc K sX |� � }|�� }|d |d |d |d |d |d g}| j||f|�\}}||fS )a Add an inset indicator rectangle to the axes based on the axis limits for an *inset_ax* and draw connectors between *inset_ax* and the rectangle. Warnings -------- This method is experimental as of 3.0, and the API may change. Parameters ---------- inset_ax : `.Axes` Inset axes to draw connecting lines to. Two lines are drawn connecting the indicator box to the inset axes on corners chosen so as to not overlap with the indicator box. **kwargs Other *kwargs* are passed on to `.Axes.inset_rectangle` Returns ------- rectangle_patch : `.Patches.Rectangle` Rectangle artist. connector_lines : 4-tuple of `.Patches.ConnectionPatch` One for each of four connector lines. Two are set with visibility to *False*, but the user can set the visibility to True if the automatic choice is not deemed correct. r r )Zget_xlimZget_ylimrg )r- ra rD ZxlimZylimZrectrw rx r r r �indicate_inset_zoomJ s #, ��zAxes.indicate_inset_zoom)� functionsc K s> |dkst |t�r2t| d||f|�}| �|� |S td��dS )a� Add a second x-axis to this axes. For example if we want to have a second scale for the data plotted on the xaxis. %(_secax_docstring)s Examples -------- The main axis shows frequency, and the secondary axis shows period. .. plot:: fig, ax = plt.subplots() ax.loglog(range(1, 360, 5), range(1, 360, 5)) ax.set_xlabel('frequency [Hz]') def invert(x): return 1 / x secax = ax.secondary_xaxis('top', functions=(invert, invert)) secax.set_xlabel('Period [s]') plt.show() )�top�bottom�xzAsecondary_xaxis location must be either a float or "top"/"bottom"N�r r r r` r9 �r- �locationr| rD Z secondary_axr r r �secondary_xaxisu s � zAxes.secondary_xaxisc K s> |dkst |t�r2t| d||f|�}| �|� |S td��dS )ah Add a second y-axis to this axes. For example if we want to have a second scale for the data plotted on the yaxis. %(_secax_docstring)s Examples -------- Add a secondary axes that converts from radians to degrees .. plot:: fig, ax = plt.subplots() ax.plot(range(1, 360, 5), range(1, 360, 5)) ax.set_ylabel('degrees') secax = ax.secondary_yaxis('right', functions=(np.deg2rad, np.rad2deg)) secax.set_ylabel('radians') )r1 r2 �yzAsecondary_yaxis location must be either a float or "left"/"right"Nr� r� r r r �secondary_yaxis� s �� zAxes.secondary_yaxis�withdashFc K sx |dkr i }dd| j dd�||�}|rD|tjjk rDtj|||d�}ntj|||d�}|�|� |�| j � | � |� |S )at Add text to the axes. Add the text *s* to the axes at location *x*, *y* in data coordinates. Parameters ---------- x, y : scalars The position to place the text. By default, this is in data coordinates. The coordinate system can be changed using the *transform* parameter. s : str The text. fontdict : dictionary, optional, default: None A dictionary to override the default text properties. If fontdict is None, the defaults are determined by your rc parameters. withdash : boolean, optional, default: False Creates a `~matplotlib.text.TextWithDash` instance instead of a `~matplotlib.text.Text` instance. Returns ------- text : `.Text` The created `.Text` instance. Other Parameters ---------------- **kwargs : `~matplotlib.text.Text` properties. Other miscellaneous text parameters. Examples -------- Individual keyword arguments can be used to override any given parameter:: >>> text(x, y, s, fontsize=12) The default transform specifies that text is in data coords, alternatively, you can specify text in axis coords (0,0 is lower-left and 1,1 is upper-right). The example below places text in the center of the axes:: >>> text(0.5, 0.5, 'matplotlib', horizontalalignment='center', ... verticalalignment='center', transform=ax.transAxes) You can put a rectangular box around the text instance (e.g., to set a background color) by using the keyword `bbox`. `bbox` is a dictionary of `~matplotlib.patches.Rectangle` properties. For example:: >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5)) Nr= r1 F)r> r? r\ �clip_on)�text) rm �cbookZ deprecationZ_deprecated_parameter�mtextZ TextWithDashZTextrA � set_clip_path�patch� _add_text) r- r r� �srC r� rD Zeffective_kwargs�tr r r r� � s& 9�� � z Axes.textc O sD t j||f|�|�}|�t�� � d|kr6|�| j� | �|� |S )Nr� )r� � Annotation� set_transformr �IdentityTransformr� r� r� )r- r� rv rY rD �ar r r �annotate s z Axes.annotater r c K s� d|krt d��| �� \}}| j||d� | �|�}||k pB||k}| jdd�} tj||g||gfd| i|��} | �| � | jd|d� | S )ai Add a horizontal line across the axis. Parameters ---------- y : scalar, optional, default: 0 y position in data coordinates of the horizontal line. xmin : scalar, optional, default: 0 Should be between 0 and 1, 0 being the far left of the plot, 1 the far right of the plot. xmax : scalar, optional, default: 1 Should be between 0 and 1, 0 being the far left of the plot, 1 the far right of the plot. Returns ------- line : :class:`~matplotlib.lines.Line2D` Other Parameters ---------------- **kwargs Valid kwargs are :class:`~matplotlib.lines.Line2D` properties, with the exception of 'transform': %(_Line2D_docstr)s See also -------- hlines : Add horizontal lines in data coordinates. axhspan : Add a horizontal span (rectangle) across the axis. Examples -------- * draw a thick red hline at 'y' = 0 that spans the xrange:: >>> axhline(linewidth=4, color='r') * draw a default hline at 'y' = 1 that spans the xrange:: >>> axhline(y=1) * draw a default hline at 'y' = .5 that spans the middle half of the xrange:: >>> axhline(y=.5, xmin=0.25, xmax=0.75) r\ zJ'transform' is not allowed as a kwarg;axhline generates its own transform.)�ydatarD �grid�ZwhichF��scalex�scaley) r9 Z get_ybound�_process_unit_info�convert_yunits�get_yaxis_transform�mlines�Line2D�add_line�autoscale_view) r- r� �xmin�xmaxrD �ymin�ymaxZyyr� r' �lr r r �axhline s 4� z Axes.axhlinec K s� d|krt d��| �� \}}| j||d� | �|�}||k pB||k}| jdd�} tj||g||gfd| i|��} | �| � | j|dd� | S )aO Add a vertical line across the axes. Parameters ---------- x : scalar, optional, default: 0 x position in data coordinates of the vertical line. ymin : scalar, optional, default: 0 Should be between 0 and 1, 0 being the bottom of the plot, 1 the top of the plot. ymax : scalar, optional, default: 1 Should be between 0 and 1, 0 being the bottom of the plot, 1 the top of the plot. Returns ------- line : :class:`~matplotlib.lines.Line2D` Other Parameters ---------------- **kwargs Valid kwargs are :class:`~matplotlib.lines.Line2D` properties, with the exception of 'transform': %(_Line2D_docstr)s Examples -------- * draw a thick red vline at *x* = 0 that spans the yrange:: >>> axvline(linewidth=4, color='r') * draw a default vline at *x* = 1 that spans the yrange:: >>> axvline(x=1) * draw a default vline at *x* = .5 that spans the middle half of the yrange:: >>> axvline(x=.5, ymin=0.25, ymax=0.75) See also -------- vlines : Add vertical lines in data coordinates. axvspan : Add a vertical span (rectangle) across the axis. r\ zJ'transform' is not allowed as a kwarg;axvline generates its own transform.��xdatarD r� r� Fr� ) r9 Z get_xboundr� �convert_xunits�get_xaxis_transformr� r� r� r� ) r- r r� r� rD r� r� Zxxr� r' r� r r r �axvlinef s 3� z Axes.axvlinec K s� | j dd�}| j||g||g|d� | �||g�\}}| �||g�\}}||f||f||f||ff}tj|f|�}|�|� | �|� | jdd� |S )a� Add a horizontal span (rectangle) across the axis. Draw a horizontal span (rectangle) from *ymin* to *ymax*. With the default values of *xmin* = 0 and *xmax* = 1, this always spans the xrange, regardless of the xlim settings, even if you change them, e.g., with the :meth:`set_xlim` command. That is, the horizontal extent is in axes coords: 0=left, 0.5=middle, 1.0=right but the *y* location is in data coordinates. Parameters ---------- ymin : float Lower limit of the horizontal span in data units. ymax : float Upper limit of the horizontal span in data units. xmin : float, optional, default: 0 Lower limit of the vertical span in axes (relative 0-1) units. xmax : float, optional, default: 1 Upper limit of the vertical span in axes (relative 0-1) units. Returns ------- Polygon : `~matplotlib.patches.Polygon` Other Parameters ---------------- **kwargs : `~matplotlib.patches.Polygon` properties. %(Polygon)s See Also -------- axvspan : Add a vertical span across the axes. r� r� �rD F)r� ) r� r� r� r� rn �Polygonr� rp r� ) r- r� r� r� r� rD r' �verts�pr r r �axhspan� s ( z Axes.axhspanc K s� | j dd�}| j||g||g|d� | �||g�\}}| �||g�\}}||f||f||f||fg}tj|f|�}|�|� | �|� | jdd� |S )a� Add a vertical span (rectangle) across the axes. Draw a vertical span (rectangle) from `xmin` to `xmax`. With the default values of `ymin` = 0 and `ymax` = 1. This always spans the yrange, regardless of the ylim settings, even if you change them, e.g., with the :meth:`set_ylim` command. That is, the vertical extent is in axes coords: 0=bottom, 0.5=middle, 1.0=top but the x location is in data coordinates. Parameters ---------- xmin : scalar Number indicating the first X-axis coordinate of the vertical span rectangle in data units. xmax : scalar Number indicating the second X-axis coordinate of the vertical span rectangle in data units. ymin : scalar, optional Number indicating the first Y-axis coordinate of the vertical span rectangle in relative Y-axis units (0-1). Default to 0. ymax : scalar, optional Number indicating the second Y-axis coordinate of the vertical span rectangle in relative Y-axis units (0-1). Default to 1. Returns ------- rectangle : `~matplotlib.patches.Polygon` Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax). Other Parameters ---------------- **kwargs Optional parameters are properties of the class `.Polygon`. See Also -------- axhspan : Add a horizontal span across the axes. Examples -------- Draw a vertical, green, translucent rectangle from x = 1.25 to x = 1.55 that spans the yrange of the axes. >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5) r� r� r� F)r� ) r� r� r� r� rn r� r� rp r� ) r- r� r� r� r� rD r' r� r� r r r �axvspan� s 0 z Axes.axvspanr� r� r� �colors)� replace_namesZ label_namer�k�solid� c K sD | j ||g||d� | �|�}| �|�}| �|�}t�|�sB|g}t�|�sR|g}t�|�sb|g}t�|||�\}}}t�|�}t�||j �}t�||j �}dd� t |||�D �}t j ||||d�} | j | dd� | �|� t|�dk�r@t|�� |�� �} t|�� |�� �} |�� } |�� } | | f| | ff}| �|� | �� | S )au Plot horizontal lines at each *y* from *xmin* to *xmax*. Parameters ---------- y : scalar or sequence of scalar y-indexes where to plot the lines. xmin, xmax : scalar or 1D array_like Respective beginning and end of each line. If scalars are provided, all lines will have same length. colors : array_like of colors, optional, default: 'k' linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional label : string, optional, default: '' Returns ------- lines : `~matplotlib.collections.LineCollection` Other Parameters ---------------- **kwargs : `~matplotlib.collections.LineCollection` properties. See also -------- vlines : vertical lines axhline: horizontal line across the axes r� c S s" g | ]\}}}||f||ff�qS r r )�.0ZthisxminZthisxmax�thisyr r r � <listcomp>[ s �z Axes.hlines.<locals>.<listcomp>�r� � linestylesrB F�Zautolimr )r� r� r� r �iterabler� �delete_masked_points�ravel�resize�shape�zip�mcoll�LineCollection�add_collectionrA rU r r �update_datalimr� )r- r� r� r� r� r� rB rD r� �lines�minx�maxx�miny�maxy�cornersr r r �hlines# s@ & � � z Axes.hlinesr r� r� c K sD | j |||g|d� | �|�}| �|�}| �|�}t�|�sB|g}t�|�sR|g}t�|�sb|g}t�|||�\}}}t�|�}t�||j �}t�||j �}dd� t |||�D �}t j ||||d�} | j | dd� | �|� t|�dk�r@|�� } |�� } t|�� |�� �} t|�� |�� �} | | f| | ff}| �|� | �� | S )a� Plot vertical lines. Plot vertical lines at each *x* from *ymin* to *ymax*. Parameters ---------- x : scalar or 1D array_like x-indexes where to plot the lines. ymin, ymax : scalar or 1D array_like Respective beginning and end of each line. If scalars are provided, all lines will have same length. colors : array_like of colors, optional, default: 'k' linestyles : {'solid', 'dashed', 'dashdot', 'dotted'}, optional label : string, optional, default: '' Returns ------- lines : `~matplotlib.collections.LineCollection` Other Parameters ---------------- **kwargs : `~matplotlib.collections.LineCollection` properties. See also -------- hlines : horizontal lines axvline: vertical line across the axes �r� r� rD c S s" g | ]\}}}||f||ff�qS r r )r� �thisxZthisyminZthisymaxr r r r� � s �z Axes.vlines.<locals>.<listcomp>r� Fr� r )r� r� r� r r� r� r� r� r� r� r� r� r� r� rA rU r r r� r� )r- r r� r� r� r� rB rD r� r� r� r� r� r� r� r r r �vlineso s@ & � � z Axes.vlines� positions� lineoffsets� linelengths� linewidthsr� )r� � horizontalc K s | j |||g|d� | �|�}| �|�}| �|�}t�|�sD|g}n.tdd� |D ��rfdd� |D �}n t�|�g}t|�dkr�g S t� ||d�}t� ||d�}t� ||d �}t�|�s�|g}t�|�s�|g}t�|�s�|g}t�|�s�|g}t |d ��st�|��s |g}t� |�}t� |�}t� |�}t|�dk�r<d g}t|�dk�rPd g}t|�dk�rdd g}t|�dk�rxd g}t|�dk�r�d g}zt � |�}W n tk �r� Y nX t|�d k�r�t|�d k�r�t�|t|��}d|d< t�|�}t|�d k�rt�|t|��}t|�d k�r,t�|t|��}t|�d k�rNt|�}|t|� }t|�d k�rj|gt|� }t|�t|�k�r�td ��t|�t|�k�r�td��t|�t|�k�r�td��t|�t|�k�r�td��t|�t|�k�r�td��g } t||||||�D ]L\} } } } }}tj| || | | ||d�}| j|dd� |�|� | �|� �qt|�dk�r�dd� |D �}t|�dk�r�t|� \}}t�|�}t�|�}|| �� }|| �� }|d k �r�|�� dk�r�||f||ff}n||f||ff}| �|� | � � | S )a� Plot identical parallel lines at the given positions. *positions* should be a 1D or 2D array-like object, with each row corresponding to a row or column of lines. This type of plot is commonly used in neuroscience for representing neural events, where it is usually called a spike raster, dot raster, or raster plot. However, it is useful in any situation where you wish to show the timing or position of multiple sets of discrete events, such as the arrival times of people to a business on each day of the month or the date of hurricanes each year of the last century. Parameters ---------- positions : 1D or 2D array-like object Each value is an event. If *positions* is a 2D array-like, each row corresponds to a row or a column of lines (depending on the *orientation* parameter). orientation : {'horizontal', 'vertical'}, optional Controls the direction of the event collections: - 'horizontal' : the lines are arranged horizontally in rows, and are vertical. - 'vertical' : the lines are arranged vertically in columns, and are horizontal. lineoffsets : scalar or sequence of scalars, optional, default: 1 The offset of the center of the lines from the origin, in the direction orthogonal to *orientation*. linelengths : scalar or sequence of scalars, optional, default: 1 The total height of the lines (i.e. the lines stretches from ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``). linewidths : scalar, scalar sequence or None, optional, default: None The line width(s) of the event lines, in points. If it is None, defaults to its rcParams setting. colors : color, sequence of colors or None, optional, default: None The color(s) of the event lines. If it is None, defaults to its rcParams setting. linestyles : str or tuple or a sequence of such values, optional Default is 'solid'. Valid strings are ['solid', 'dashed', 'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples should be of the form:: (offset, onoffseq), where *onoffseq* is an even length tuple of on and off ink in points. **kwargs : optional Other keyword arguments are line collection properties. See :class:`~matplotlib.collections.LineCollection` for a list of the valid properties. Returns ------- list : A list of :class:`~.collections.EventCollection` objects. Contains the :class:`~.collections.EventCollection` that were added. Notes ----- For *linelengths*, *linewidths*, *colors*, and *linestyles*, if only a single value is given, that value is applied to all lines. If an array-like is given, it must have the same length as *positions*, and each value will be applied to the corresponding row of the array. Examples -------- .. plot:: gallery/lines_bars_and_markers/eventplot_demo.py r� c s s | ]}t �|�V qd S r )r r� �r� �positionr r r � <genexpr> s z!Axes.eventplot.<locals>.<genexpr>c S s g | ]}t �|��qS r )r � asanyarrayr� r r r r� s z"Axes.eventplot.<locals>.<listcomp>r �color� linewidth� linestyler7 Nr z5lineoffsets and positions are unequal sized sequencesz5linelengths and positions are unequal sized sequencesz4linewidths and positions are unequal sized sequencesz0colors and positions are unequal sized sequencesz4linestyles and positions are unequal sized sequences)� orientation� lineoffset� linelengthr� r� r� Fr� c S s, g | ]$}t |�d krt�|�t�|�f�qS )r )rU r r r )r� Z_pr r r r� s ��vertical) r� r� r� r r� �anyr� rU r� Zlocal_over_kwdict�hasattr�asarray�mcolors� to_rgba_arrayr9 �tile�cumsum�listr� r� ZEventCollectionr� rA �appendr r r7 r� r� )r- r� r� r� r� r� r� r� rD Zcollsr� r� r� r� r� r� ZcollZmin_max�mins�maxesZminposZmaxposZminlineZmaxliner� r r r � eventplot� s� X� ��� � zAxes.eventplotT)r� r� rj c O sL t �|tjj�}| j|d|i|���}|D ]}| �|� q*| j||d� |S )a�! Plot y versus x as lines and/or markers. Call signatures:: plot([x], y, [fmt], *, data=None, **kwargs) plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs) The coordinates of the points or line nodes are given by *x*, *y*. The optional parameter *fmt* is a convenient way for defining basic formatting like color, marker and linestyle. It's a shortcut string notation described in the *Notes* section below. >>> plot(x, y) # plot x and y using default line style and color >>> plot(x, y, 'bo') # plot x and y using blue circle markers >>> plot(y) # plot y using x as index array 0..N-1 >>> plot(y, 'r+') # ditto, but with red plusses You can use `.Line2D` properties as keyword arguments for more control on the appearance. Line properties and *fmt* can be mixed. The following two calls yield identical results: >>> plot(x, y, 'go--', linewidth=2, markersize=12) >>> plot(x, y, color='green', marker='o', linestyle='dashed', ... linewidth=2, markersize=12) When conflicting with *fmt*, keyword arguments take precedence. **Plotting labelled data** There's a convenient way for plotting objects with labelled data (i.e. data that can be accessed by index ``obj['y']``). Instead of giving the data in *x* and *y*, you can provide the object in the *data* parameter and just give the labels for *x* and *y*:: >>> plot('xlabel', 'ylabel', data=obj) All indexable objects are supported. This could e.g. be a `dict`, a `pandas.DataFame` or a structured numpy array. **Plotting multiple sets of data** There are various ways to plot multiple sets of data. - The most straight forward way is just to call `plot` multiple times. Example: >>> plot(x1, y1, 'bo') >>> plot(x2, y2, 'go') - Alternatively, if your data is already a 2d array, you can pass it directly to *x*, *y*. A separate data set will be drawn for every column. Example: an array ``a`` where the first column represents the *x* values and the other columns are the *y* columns:: >>> plot(a[0], a[1:]) - The third way is to specify multiple sets of *[x]*, *y*, *[fmt]* groups:: >>> plot(x1, y1, 'g^', x2, y2, 'g-') In this case, any additional keyword argument applies to all datasets. Also this syntax cannot be combined with the *data* parameter. By default, each line is assigned a different style specified by a 'style cycle'. The *fmt* and line property parameters are only necessary if you want explicit deviations from these defaults. Alternatively, you can also change the style cycle using the 'axes.prop_cycle' rcParam. Parameters ---------- x, y : array-like or scalar The horizontal / vertical coordinates of the data points. *x* values are optional and default to `range(len(y))`. Commonly, these parameters are 1D arrays. They can also be scalars, or two-dimensional (in that case, the columns represent separate data sets). These arguments cannot be passed as keywords. fmt : str, optional A format string, e.g. 'ro' for red circles. See the *Notes* section for a full description of the format strings. Format strings are just an abbreviation for quickly setting basic line properties. All of these and more can also be controlled by keyword arguments. This argument cannot be passed as keyword. data : indexable object, optional An object with labelled data. If given, provide the label names to plot in *x* and *y*. .. note:: Technically there's a slight ambiguity in calls where the second label is a valid *fmt*. `plot('n', 'o', data=obj)` could be `plt(x, y)` or `plt(y, fmt)`. In such cases, the former interpretation is chosen, but a warning is issued. You may suppress the warning by adding an empty format string `plot('n', 'o', '', data=obj)`. Other Parameters ---------------- scalex, scaley : bool, optional, default: True These parameters determined if the view limits are adapted to the data limits. The values are passed on to `autoscale_view`. **kwargs : `.Line2D` properties, optional *kwargs* are used to specify properties like a line label (for auto legends), linewidth, antialiasing, marker face color. Example:: >>> plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2) >>> plot([1,2,3], [1,4,9], 'rs', label='line 2') If you make multiple lines with one plot command, the kwargs apply to all those lines. Here is a list of available `.Line2D` properties: %(_Line2D_docstr)s Returns ------- lines A list of `.Line2D` objects representing the plotted data. See Also -------- scatter : XY scatter plot with markers of varying size and/or color ( sometimes also called bubble chart). Notes ----- **Format Strings** A format string consists of a part for color, marker and line:: fmt = '[marker][line][color]' Each of them is optional. If not provided, the value from the style cycle is used. Exception: If ``line`` is given, but no ``marker``, the data will be a line without markers. Other combinations such as ``[color][marker][line]`` are also supported, but note that their parsing may be ambiguous. **Markers** ============= =============================== character description ============= =============================== ``'.'`` point marker ``','`` pixel marker ``'o'`` circle marker ``'v'`` triangle_down marker ``'^'`` triangle_up marker ``'<'`` triangle_left marker ``'>'`` triangle_right marker ``'1'`` tri_down marker ``'2'`` tri_up marker ``'3'`` tri_left marker ``'4'`` tri_right marker ``'s'`` square marker ``'p'`` pentagon marker ``'*'`` star marker ``'h'`` hexagon1 marker ``'H'`` hexagon2 marker ``'+'`` plus marker ``'x'`` x marker ``'D'`` diamond marker ``'d'`` thin_diamond marker ``'|'`` vline marker ``'_'`` hline marker ============= =============================== **Line Styles** ============= =============================== character description ============= =============================== ``'-'`` solid line style ``'--'`` dashed line style ``'-.'`` dash-dot line style ``':'`` dotted line style ============= =============================== Example format strings:: 'b' # blue markers with default shape 'or' # red circles '-g' # green solid line '--' # dashed line with default color '^k:' # black triangle_up markers connected by a dotted line **Colors** The supported color abbreviations are the single letter codes ============= =============================== character color ============= =============================== ``'b'`` blue ``'g'`` green ``'r'`` red ``'c'`` cyan ``'m'`` magenta ``'y'`` yellow ``'k'`` black ``'w'`` white ============= =============================== and the ``'CN'`` colors that index into the default property cycle. If the color is the only part of the format string, you can additionally use any `matplotlib.colors` spec, e.g. full names (``'green'``) or hex strings (``'#008000'``). rj r� )r� �normalize_kwargsr� r� � _alias_map� _get_linesr� r� )r- r� r� rj rY rD r� �liner r r �plot� s i z Axes.plot�oc K s: |r| � |� |r | �|� | j|||f|�}| �� |S )aU Plot data that contains dates. Similar to `.plot`, this plots *y* vs. *x* as lines or markers. However, the axis labels are formatted as dates depending on *xdate* and *ydate*. Parameters ---------- x, y : array-like The coordinates of the data points. If *xdate* or *ydate* is *True*, the respective values *x* or *y* are interpreted as :ref:`Matplotlib dates <date-format>`. fmt : str, optional The plot format string. For details, see the corresponding parameter in `.plot`. tz : [ *None* | timezone string | :class:`tzinfo` instance] The time zone to use in labeling dates. If *None*, defaults to rcParam ``timezone``. xdate : bool, optional, default: True If *True*, the *x*-axis will be interpreted as Matplotlib dates. ydate : bool, optional, default: False If *True*, the *y*-axis will be interpreted as Matplotlib dates. Returns ------- lines A list of `~.Line2D` objects representing the plotted data. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s See Also -------- matplotlib.dates : Helper functions on dates. matplotlib.dates.date2num : Convert dates to num. matplotlib.dates.num2date : Convert num to dates. matplotlib.dates.drange : Create an equally spaced sequence of dates. Notes ----- If you are using custom date tickers and formatters, it may be necessary to set the formatters/locators after the call to `.plot_date`. `.plot_date` will set the default tick locator to `.AutoDateLocator` (if the tick locator is not already set to a `.DateLocator` instance) and the default tick formatter to `.AutoDateFormatter` (if the tick formatter is not already set to a `.DateFormatter` instance). )Z xaxis_dateZ yaxis_dater� r� ) r- r r� �fmtZtzZxdateZydaterD �retr r r � plot_date� s B zAxes.plot_datec sL � fdd�dD �}� fdd�dD �}| j d|� | jd|� | j|� �}|S ) a� Make a plot with log scaling on both the x and y axis. Call signatures:: loglog([x], y, [fmt], data=None, **kwargs) loglog([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs) This is just a thin wrapper around `.plot` which additionally changes both the x-axis and the y-axis to log scaling. All of the concepts and parameters of plot can be used here as well. The additional parameters *basex/y*, *subsx/y* and *nonposx/y* control the x/y-axis properties. They are just forwarded to `.Axes.set_xscale` and `.Axes.set_yscale`. Parameters ---------- basex, basey : scalar, optional, default 10 Base of the x/y logarithm. subsx, subsy : sequence, optional The location of the minor x/y ticks. If *None*, reasonable locations are automatically chosen depending on the number of decades in the plot. See `.Axes.set_xscale` / `.Axes.set_yscale` for details. nonposx, nonposy : {'mask', 'clip'}, optional, default 'mask' Non-positive values in x or y can be masked as invalid, or clipped to a very small positive number. Returns ------- lines A list of `~.Line2D` objects representing the plotted data. Other Parameters ---------------- **kwargs All parameters supported by `.plot`. c s i | ]}|� kr|� � |��qS r �r_ �r� r� r� r r � <dictcomp> s � z Axes.loglog.<locals>.<dictcomp>�ZbasexZsubsx�nonposxc s i | ]}|� kr|� � |��qS r r� r� r� r r r� s � �ZbaseyZsubsy�nonposy�log)r� )r� )� set_xscale� set_yscaler� )r- rY rD �dx�dyr� r r� r �loglog� s + z Axes.loglogc s. � fdd�dD �}| j d|� | j|� �}|S )aA Make a plot with log scaling on the x axis. Call signatures:: semilogx([x], y, [fmt], data=None, **kwargs) semilogx([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs) This is just a thin wrapper around `.plot` which additionally changes the x-axis to log scaling. All of the concepts and parameters of plot can be used here as well. The additional parameters *basex*, *subsx* and *nonposx* control the x-axis properties. They are just forwarded to `.Axes.set_xscale`. Parameters ---------- basex : scalar, optional, default 10 Base of the x logarithm. subsx : array_like, optional The location of the minor xticks. If *None*, reasonable locations are automatically chosen depending on the number of decades in the plot. See `.Axes.set_xscale` for details. nonposx : {'mask', 'clip'}, optional, default 'mask' Non-positive values in x can be masked as invalid, or clipped to a very small positive number. Returns ------- lines A list of `~.Line2D` objects representing the plotted data. Other Parameters ---------------- **kwargs All parameters supported by `.plot`. c s i | ]}|� kr|� � |��qS r r� r� r� r r r� 5 s � z!Axes.semilogx.<locals>.<dictcomp>r� r� )r� )r� r� �r- rY rD �dr� r r� r �semilogx s ) z Axes.semilogxc s. � fdd�dD �}| j d|� | j|� �}|S )aA Make a plot with log scaling on the y axis. Call signatures:: semilogy([x], y, [fmt], data=None, **kwargs) semilogy([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs) This is just a thin wrapper around `.plot` which additionally changes the y-axis to log scaling. All of the concepts and parameters of plot can be used here as well. The additional parameters *basey*, *subsy* and *nonposy* control the y-axis properties. They are just forwarded to `.Axes.set_yscale`. Parameters ---------- basey : scalar, optional, default 10 Base of the y logarithm. subsy : array_like, optional The location of the minor yticks. If *None*, reasonable locations are automatically chosen depending on the number of decades in the plot. See `.Axes.set_yscale` for details. nonposy : {'mask', 'clip'}, optional, default 'mask' Non-positive values in y can be masked as invalid, or clipped to a very small positive number. Returns ------- lines A list of `~.Line2D` objects representing the plotted data. Other Parameters ---------------- **kwargs All parameters supported by `.plot`. c s i | ]}|� kr|� � |��qS r r� r� r� r r r� f s � z!Axes.semilogy.<locals>.<dictcomp>r� r� )r� )r r� r r r� r �semilogy= s ) z Axes.semilogyc K s | j ||f|�S )a� Plot the autocorrelation of *x*. Parameters ---------- x : array-like detrend : callable, optional, default: `mlab.detrend_none` *x* is detrended by the *detrend* callable. This must be a function ``x = detrend(x)`` accepting and returning an `numpy.array`. Default is no normalization. normed : bool, optional, default: True If ``True``, input vectors are normalised to unit length. usevlines : bool, optional, default: True Determines the plot style. If ``True``, vertical lines are plotted from 0 to the acorr value using `Axes.vlines`. Additionally, a horizontal line is plotted at y=0 using `Axes.axhline`. If ``False``, markers are plotted at the acorr values using `Axes.plot`. maxlags : int, optional, default: 10 Number of lags to show. If ``None``, will return all ``2 * len(x) - 1`` lags. Returns ------- lags : array (length ``2*maxlags+1``) The lag vector. c : array (length ``2*maxlags+1``) The auto correlation vector. line : `.LineCollection` or `.Line2D` `.Artist` added to the axes of the correlation: - `.LineCollection` if *usevlines* is True. - `.Line2D` if *usevlines* is False. b : `.Line2D` or None Horizontal line at 0 if *usevlines* is True None *usevlines* is False. Other Parameters ---------------- linestyle : `.Line2D` property, optional The linestyle for plotting the data points. Only used if *usevlines* is ``False``. marker : str, optional, default: 'o' The marker for plotting the data points. Only used if *usevlines* is ``False``. Notes ----- The cross correlation is performed with :func:`numpy.correlate` with ``mode = "full"``. )�xcorr)r- r rD r r r �acorrm s =z Axes.acorrr c K s0 t |�}|t |�kr td��|t�|��}|t�|��}tj||dd�} |rn| t�t�||�t�||� � } |dkr~|d }||ks�|dk r�td| ��t�| |d �} | |d | || � } |r�| j| dg| f|�} |� dd � | j f |�} n.|� d d � |� d d � | j | | f|�\} d} | | | | fS )a� Plot the cross correlation between *x* and *y*. The correlation with lag k is defined as :math:`\sum_n x[n+k] \cdot y^*[n]`, where :math:`y^*` is the complex conjugate of :math:`y`. Parameters ---------- x : array-like of length n y : array-like of length n detrend : callable, optional, default: `mlab.detrend_none` *x* and *y* are detrended by the *detrend* callable. This must be a function ``x = detrend(x)`` accepting and returning an `numpy.array`. Default is no normalization. normed : bool, optional, default: True If ``True``, input vectors are normalised to unit length. usevlines : bool, optional, default: True Determines the plot style. If ``True``, vertical lines are plotted from 0 to the xcorr value using `Axes.vlines`. Additionally, a horizontal line is plotted at y=0 using `Axes.axhline`. If ``False``, markers are plotted at the xcorr values using `Axes.plot`. maxlags : int, optional, default: 10 Number of lags to show. If None, will return all ``2 * len(x) - 1`` lags. Returns ------- lags : array (length ``2*maxlags+1``) The lag vector. c : array (length ``2*maxlags+1``) The auto correlation vector. line : `.LineCollection` or `.Line2D` `.Artist` added to the axes of the correlation: - `.LineCollection` if *usevlines* is True. - `.Line2D` if *usevlines* is False. b : `.Line2D` or None Horizontal line at 0 if *usevlines* is True None *usevlines* is False. Other Parameters ---------------- linestyle : `.Line2D` property, optional The linestyle for plotting the data points. Only used if *usevlines* is ``False``. marker : str, optional, default: 'o' The marker for plotting the data points. Only used if *usevlines* is ``False``. Notes ----- The cross correlation is performed with :func:`numpy.correlate` with ``mode = "full"``. z x and y must be equal length�full)�modeNr z.maxlags must be None or strictly positive < %dr rB r� �markerr� r� �None) rU r9 r r� Z correlate�sqrt�dot�aranger� r_ r� � setdefaultr� ) r- r r� �normed�detrendZ usevlinesZmaxlagsrD �NxZcorrelsZlagsr� �br r r r � s2 D "� z Axes.xcorr�pre)�whererj c O s8 |dkrt d��d| |d< | j||f|�d|i|��S )a� Make a step plot. Call signatures:: step(x, y, [fmt], *, data=None, where='pre', **kwargs) step(x, y, [fmt], x2, y2, [fmt2], ..., *, where='pre', **kwargs) This is just a thin wrapper around `.plot` which changes some formatting options. Most of the concepts and parameters of plot can be used here as well. Parameters ---------- x : array_like 1-D sequence of x positions. It is assumed, but not checked, that it is uniformly increasing. y : array_like 1-D sequence of y levels. fmt : str, optional A format string, e.g. 'g' for a green line. See `.plot` for a more detailed description. Note: While full format strings are accepted, it is recommended to only specify the color. Line styles are currently ignored (use the keyword argument *linestyle* instead). Markers are accepted and plotted on the given positions, however, this is a rarely needed feature for step plots. data : indexable object, optional An object with labelled data. If given, provide the label names to plot in *x* and *y*. where : {'pre', 'post', 'mid'}, optional, default 'pre' Define where the steps should be placed: - 'pre': The y value is continued constantly to the left from every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the value ``y[i]``. - 'post': The y value is continued constantly to the right from every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the value ``y[i]``. - 'mid': Steps occur half-way between the *x* positions. Returns ------- lines A list of `.Line2D` objects representing the plotted data. Other Parameters ---------------- **kwargs Additional parameters are the same as those for `.plot`. Notes ----- .. [notes section required to get data note injection right] )r Zpost�midz7'where' argument to step must be 'pre', 'post' or 'mid'�steps-Z drawstylerj )r9 r� )r- r r� r rj rY rD r r r �step s = z Axes.stepc s� t |�tjkst�|jdkr$� | �S z�zt����W n ttt fk rR ��Y nX zt�|��W n ttt fk r� |�Y nX d}t� | �s�| g} d}� ��fdd�| D �} |r�| d } W n" t tt fk r� � | �} Y nX | S )aI Small helper to do logic of width conversion flexibly. *dx* and *x0* have units, but *xconv* has already been converted to unitless (and is an ndarray). This allows the *dx* to have units that are different from *x0*, but are still accepted by the ``__add__`` operator of *x0*. r FTc s g | ]}� �| �� �qS r r )r� Zddx��convertr rr r r r� � s z$Axes._convert_dx.<locals>.<listcomp>) �typer Zndarray�AssertionError�sizer� �safe_first_elementrV � IndexErrorr8 r� r9 �AttributeError)r rr Zxconvr Zdelistr r r � _convert_dxX s, zAxes._convert_dx皙�����?)�alignc . K s^ t �|tjj�}|�dd�}|dkr.| j�� }|�dd�}|�dd�} |�dd�} |�dd�} |�di �} | �dd�} | dkr�|�dd�} | dk r�| d 7 } | � d| � |�d d �}|�d t d �}| � d |� | � d |� |�dd�}|�dd�}|�dd�}|�dd�}d}d}|}|dk�rB|dk�rl| � � dk�r<d}d}n*|dk�rl|dk�rl| � � dk�rhd}d}|dk�r�| j |||d� |�r�| jddd� n<|dk�r�| j |||d� |�r�| jddd� n td | ��| jdk �r&|}t�| �|��}| �|||| j�}| dk �r&| �| ||| j�} | jdk �rt|}t�| �|��}| �|||| j�}| dk �rt| �| ||| j�} t�t�|�|||| �\}}}}} |dk�r�| j}|}n|dk�r�| j}|}t�t�| ��} t� t�t � |��t� d ��}|dk�rt� d�}n t� t�t � |��t� d ��}|d k�r�|dk�r�z||d }W n@ t k �r� } z t d |j!� d!|j!� d"��| �W 5 d} ~ X Y nX |}n`|dk�rz||d }W n@ t k �r� } z t d#|j!� d$|j!� d"��| �W 5 d} ~ X Y nX |}n |d%k�r|}|}n td&| ��g } t"||||||| �} | D ]�\} } }!}"}#} }$tj#| | f|!|"|#| |$d'd(�}%|%�$|� d)|%�%� _&|dk�r�|%j'j(�)| � n|dk�r�|%j'j*�)| � | �+|%� | �)|%� �q,| dk �s�| dk �r\|dk�r d*d+� t"||�D �}&d,d+� t"||�D �}'n2|dk�r2d-d+� t"||�D �}&d.d+� t"||�D �}'| � dd'� | j,|&|'f| | d d/�| ��}(nd}(|�r�| j-j.\})}*t/d0d1� |D ��})| dk �r�|)t�0| � })t0|)d2 d3�})|)|*f| j-_.|�r | j-j1\}+},t/d4d1� |D ��}+| dk �r�|+t�0| � }+t0|+d2 d3�}+|+|,f| j-_1| �2� t3| |(|d5�}-| �4|-� |dk �rZt�5|t6| ��}|�7|� |�8|� |-S )6a� Make a bar plot. The bars are positioned at *x* with the given *align*\ment. Their dimensions are given by *width* and *height*. The vertical baseline is *bottom* (default 0). Each of *x*, *height*, *width*, and *bottom* may either be a scalar applying to all bars, or it may be a sequence of length N providing a separate value for each bar. Parameters ---------- x : sequence of scalars The x coordinates of the bars. See also *align* for the alignment of the bars to the coordinates. height : scalar or sequence of scalars The height(s) of the bars. width : scalar or array-like, optional The width(s) of the bars (default: 0.8). bottom : scalar or array-like, optional The y coordinate(s) of the bars bases (default: 0). align : {'center', 'edge'}, optional, default: 'center' Alignment of the bars to the *x* coordinates: - 'center': Center the base on the *x* positions. - 'edge': Align the left edges of the bars with the *x* positions. To align the bars on the right edge pass a negative *width* and ``align='edge'``. Returns ------- container : `.BarContainer` Container with all the bars and optionally errorbars. Other Parameters ---------------- color : scalar or array-like, optional The colors of the bar faces. edgecolor : scalar or array-like, optional The colors of the bar edges. linewidth : scalar or array-like, optional Width of the bar edge(s). If 0, don't draw edges. tick_label : string or array-like, optional The tick labels of the bars. Default: None (Use default numeric labels.) xerr, yerr : scalar or array-like of shape(N,) or shape(2,N), optional If not *None*, add horizontal / vertical errorbars to the bar tips. The values are +/- sizes relative to the data: - scalar: symmetric +/- values for all bars - shape(N,): symmetric +/- values for each bar - shape(2,N): Separate - and + values for each bar. First row contains the lower errors, the second row contains the upper errors. - *None*: No errorbar. (Default) See :doc:`/gallery/statistics/errorbar_features` for an example on the usage of ``xerr`` and ``yerr``. ecolor : scalar or array-like, optional, default: 'black' The line color of the errorbars. capsize : scalar, optional The length of the error bar caps in points. Default: None, which will take the value from :rc:`errorbar.capsize`. error_kw : dict, optional Dictionary of kwargs to be passed to the `~.Axes.errorbar` method. Values of *ecolor* or *capsize* defined here take precedence over the independent kwargs. log : bool, optional, default: False If *True*, set the y-axis to be log scale. orientation : {'vertical', 'horizontal'}, optional *This is for internal use only.* Please use `barh` for horizontal bar plots. Default: 'vertical'. See also -------- barh: Plot a horizontal bar plot. Notes ----- The optional arguments *color*, *edgecolor*, *linewidth*, *xerr*, and *yerr* can be either scalars or sequences of length equal to the number of bars. This enables you to use bar as the basis for stacked bar charts, or candlestick plots. Detail: *xerr* and *yerr* are passed directly to :meth:`errorbar`, so they can also have shape 2xN for independent specification of lower and upper errors. Other optional kwargs: %(Rectangle)s r� Nre r� �xerr�yerr�error_kwr] �{�G�z�?�ecolorr� �capsize�errorbar.capsizer� r� r� FrB r� Z tick_labelTr r� r� �clip�r� �r� zinvalid orientation: %srb r/ rh z the dtypes of parameters x (z ) and width (z) are incompatiblez the dtypes of parameters y (z) and height (Zedgezinvalid alignment: %s� _nolegend_)rv �width�heightrd re r� rB �d c S s g | ]\}}|d | �qS �rc r �r� r� �wr r r r� � s z Axes.bar.<locals>.<listcomp>c S s g | ]\}}|| �qS r r �r� r �hr r r r� � s c S s g | ]\}}|| �qS r r r5 r r r r� � s c S s g | ]\}}|d | �qS r4 r r7 r r r r� � s )r' r& r� c s s | ]}|d kr|V qdS �r Nr )r� r6 r r r r� � s zAxes.bar.<locals>.<genexpr>��������?g0��.�++c s s | ]}|d kr|V qdS r9 r )r� r8 r r r r� � s �rB )9r� r� rn �Patchr� r_ �_get_patches_for_fill�get_next_color�getr r Z get_yscaleZ get_xscaler� r r� r9 rG r r� r� r# rN r� �broadcast_arrays� atleast_1d� itertools�cycle�chainr� r� �repeatrV �dtyper� ro rA �get_pathZ_interpolation_steps� sticky_edgesr� r� r rp �errorbar�dataLimZ intervalxr r � intervalyr� r � add_container� broadcast_torU Z set_ticksZset_ticklabels).r- r r2 r1 r~ r% rD r� re r� r& r' r( Zezorderr* r+ r� r� rB Z tick_labelsZ adjust_ylimZ adjust_xlimr� rr rt Ztick_label_axisZtick_label_positionr1 �e�patchesrY r� r r6 r8 �cZlw�r�exZeyrI r� r� r� r� Z bar_containerr r r �bar� s> p � � � � � � �� zAxes.barc K s, |� dd� | jf |||||d�|��}|S )a� Make a horizontal bar plot. The bars are positioned at *y* with the given *align*\ment. Their dimensions are given by *width* and *height*. The horizontal baseline is *left* (default 0). Each of *y*, *width*, *height*, and *left* may either be a scalar applying to all bars, or it may be a sequence of length N providing a separate value for each bar. Parameters ---------- y : scalar or array-like The y coordinates of the bars. See also *align* for the alignment of the bars to the coordinates. width : scalar or array-like The width(s) of the bars. height : sequence of scalars, optional, default: 0.8 The heights of the bars. left : sequence of scalars The x coordinates of the left sides of the bars (default: 0). align : {'center', 'edge'}, optional, default: 'center' Alignment of the base to the *y* coordinates*: - 'center': Center the bars on the *y* positions. - 'edge': Align the bottom edges of the bars with the *y* positions. To align the bars on the top edge pass a negative *height* and ``align='edge'``. Returns ------- container : `.BarContainer` Container with all the bars and optionally errorbars. Other Parameters ---------------- color : scalar or array-like, optional The colors of the bar faces. edgecolor : scalar or array-like, optional The colors of the bar edges. linewidth : scalar or array-like, optional Width of the bar edge(s). If 0, don't draw edges. tick_label : string or array-like, optional The tick labels of the bars. Default: None (Use default numeric labels.) xerr, yerr : scalar or array-like of shape(N,) or shape(2,N), optional If not ``None``, add horizontal / vertical errorbars to the bar tips. The values are +/- sizes relative to the data: - scalar: symmetric +/- values for all bars - shape(N,): symmetric +/- values for each bar - shape(2,N): Separate - and + values for each bar. First row contains the lower errors, the second row contains the upper errors. - *None*: No errorbar. (default) See :doc:`/gallery/statistics/errorbar_features` for an example on the usage of ``xerr`` and ``yerr``. ecolor : scalar or array-like, optional, default: 'black' The line color of the errorbars. capsize : scalar, optional The length of the error bar caps in points. Default: None, which will take the value from :rc:`errorbar.capsize`. error_kw : dict, optional Dictionary of kwargs to be passed to the `~.Axes.errorbar` method. Values of *ecolor* or *capsize* defined here take precedence over the independent kwargs. log : bool, optional, default: False If ``True``, set the x-axis to be log scale. See also -------- bar: Plot a vertical bar plot. Notes ----- The optional arguments *color*, *edgecolor*, *linewidth*, *xerr*, and *yerr* can be either scalars or sequences of length equal to the number of bars. This enables you to use bar as the basis for stacked bar charts, or candlestick plots. Detail: *xerr* and *yerr* are passed directly to :meth:`errorbar`, so they can also have shape 2xN for independent specification of lower and upper errors. Other optional kwargs: %(Rectangle)s r� r� )r r2 r1 r~ r% )r rS )r- r� r1 r2 r1 r% rD rO r r r �barh� s l ��z Axes.barhc K s� t |�rt�|�}nd}t |�r,t�|�}nd}| j|||d� g }|D ]T}t |�dkr`td��t�| �|d ��}| �|d |d || j�} |� || f� qH| � |�} t j || f|�} | j | dd� | �� | S ) a+ Plot a horizontal sequence of rectangles. A rectangle is drawn for each element of *xranges*. All rectangles have the same vertical position and size defined by *yrange*. This is a convenience function for instantiating a `.BrokenBarHCollection`, adding it to the axes and autoscaling the view. Parameters ---------- xranges : sequence of tuples (*xmin*, *xwidth*) The x-positions and extends of the rectangles. For each tuple (*xmin*, *xwidth*) a rectangle is drawn from *xmin* to *xmin* + *xwidth*. yranges : (*ymin*, *ymax*) The y-position and extend for all the rectangles. Other Parameters ---------------- **kwargs : :class:`.BrokenBarHCollection` properties Each *kwarg* can be either a single argument applying to all rectangles, e.g.:: facecolors='black' or a sequence of arguments over which is cycled, e.g.:: facecolors=('black', 'blue') would create interleaving black and blue rectangles. Supported keywords: %(BrokenBarHCollection)s Returns ------- collection : A :class:`~.collections.BrokenBarHCollection` Nr� rh zMeach range in xrange must be a sequence with two elements (i.e. an Nx2 array)r r Tr� )rU r� r r� r9 r r� r� r# r� r� r� ZBrokenBarHCollectionr� r� ) r- ZxrangesZyrangerD r� r� Z xranges_convry Zx_convrs Z yrange_conv�colr r r � broken_barh' s, . � zAxes.broken_barh)�linefmt� markerfmt�basefmtr~ rB �use_line_collectionc s� dt |� krdks(n td�|���t�|d �}|dd� }|sVt�t |��} n"|} tj|d td�}|dd� }| j| |d� | �| �} | � |�}|dkr�z |d }W n t k r� d} d } d } Y q�X t |�\} } } nt |�\} } } |dk�r8z |d }W n" t k �r& d} d }d }Y nX t |�\}}} nt |�\}}} |dk�r�z |d }W n2 t k �r� t d �r~d}nd}d }d }Y nX t |�\}}}nt |�\}}}|�r�� fdd�t | |�D �}| dk�r�t d } tj|| | dd�}| �|� nNt�d� g }t | |�D ]4\}}| j||g� |g| | | dd�\}|�|� �q| j| || ||dd�\}| jt�| �t�| �g� � g|||dd�\}t|||f|d�}| �|� |S )a� Create a stem plot. A stem plot plots vertical lines at each *x* location from the baseline to *y*, and places a marker there. Call signature:: stem([x,] y, linefmt=None, markerfmt=None, basefmt=None) The x-positions are optional. The formats may be provided either as positional or as keyword-arguments. Parameters ---------- x : array-like, optional The x-positions of the stems. Default: (0, 1, ..., len(y) - 1). y : array-like The y-values of the stem heads. linefmt : str, optional A string defining the properties of the vertical lines. Usually, this will be a color or a color and a linestyle: ========= ============= Character Line Style ========= ============= ``'-'`` solid line ``'--'`` dashed line ``'-.'`` dash-dot line ``':'`` dotted line ========= ============= Default: 'C0-', i.e. solid line with the first color of the color cycle. Note: While it is technically possible to specify valid formats other than color or color and linestyle (e.g. 'rx' or '-.'), this is beyond the intention of the method and will most likely not result in a reasonable reasonable plot. markerfmt : str, optional A string defining the properties of the markers at the stem heads. Default: 'C0o', i.e. filled circles with the first color of the color cycle. basefmt : str, optional A format string defining the properties of the baseline. Default: 'C3-' ('C2-' in classic mode). bottom : float, optional, default: 0 The y-position of the baseline. label : str, optional, default: None The label to use for the stems in legends. use_line_collection : bool, optional, default: False If ``True``, store and plot the stem lines as a `~.collections.LineCollection` instead of individual lines. This significantly increases performance, and will become the default option in Matplotlib 3.3. If ``False``, defaults to the old behavior of using a list of `.Line2D` objects. Returns ------- container : :class:`~matplotlib.container.StemContainer` The container may be treated like a tuple (*markerline*, *stemlines*, *baseline*) Notes ----- .. seealso:: The MATLAB function `stem <http://www.mathworks.com/help/techdoc/ref/stem.html>`_ which inspired this method. r r[ z:stem expected between 1 and 5 positional arguments, got {}r N�rF )r� r� �C0r rk r� rh �_internal.classic_modeZC2ZC3c s g | ]\}}|� f||ff�qS r r )r� �xi�yi�r~ r r r� s z Axes.stem.<locals>.<listcomp>zlines.linestyler0 )r� r� rB a In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the "use_line_collection" keyword argument to True.)r� r� r rB r; )rU rV �formatr r� r r@ r� r� r� r! r r r� r� r� r� r� �_warn_externalr� r� r r r rL )r- rW rX rY r~ rB rZ rY r� r Z linecolorZ linemarkerr� Z markercolorZ markermarkerZ markerstyleZ basecolorZ basemarkerZ basestyleZ stemlinesr^ r_ r� Z markerliner= Zstem_containerr r` r �stemr s� U� � � � � � � � � � � z Axes.stem�exploderS �333333�?皙�����?�r r c ( sB | � d� t�|tj�}|jdkrL|�� jdkrLtjddd� t�|�� �}|� � }|dkrd|| }|dkrzdgt |� }|dkr�dgt |� }t |�t |�kr�t d ��t |�t |�kr�t d ��|dkr�| j j }nt�|�� � fd d �}| dkr�d} | dk�rd}n| d }| dk�ri } | �dd� | dk�r4i } | �dd� g }g }g }d}t|||�D �]b\}}}|\}}| �r~|| n|| } dtj d || } ||t�| � 7 }||t�| � 7 }tj||f| d t|| � d t|| � fd|� i| ��} |�| � | �| � | � |� |�rNt� | dd�} | � d| � � � | � d� | �| � |dk �r||| t�| � } ||| t�| � }!| dk�r�d�p�d}"d}#d}$|�r�|!dk�r�d�p�d}#t� | �| dk�r�dnd }$t!|"|#|$t"d d �}%|%�#| � | j$| |!|f|%�}&|�|&� |dk �r�||| t�| � } ||| t�| � }!t%|t&��r`|d | }'n t'|��rx|d | �}'nt(d ��t!ddd!�}%|%�#| � | j$| |!|'f|%�}&|�|&� | }|d7 }�q\|�s"| �)d� | �*d"|d d#|d f� | �+d"|d d#|d f� | �,g � | �-g � |dk�r4||fS |||fS dS )$a� Plot a pie chart. Make a pie chart of array *x*. The fractional area of each wedge is given by ``x/sum(x)``. If ``sum(x) < 1``, then the values of *x* give the fractional area directly and the array will not be normalized. The resulting pie will have an empty wedge of size ``1 - sum(x)``. The wedges are plotted counterclockwise, by default starting from the x-axis. Parameters ---------- x : array-like The wedge sizes. explode : array-like, optional, default: None If not *None*, is a ``len(x)`` array which specifies the fraction of the radius with which to offset each wedge. labels : list, optional, default: None A sequence of strings providing the labels for each wedge colors : array-like, optional, default: None A sequence of matplotlib color args through which the pie chart will cycle. If *None*, will use the colors in the currently active cycle. autopct : None (default), string, or function, optional If not *None*, is a string or function used to label the wedges with their numeric value. The label will be placed inside the wedge. If it is a format string, the label will be ``fmt%pct``. If it is a function, it will be called. pctdistance : float, optional, default: 0.6 The ratio between the center of each pie slice and the start of the text generated by *autopct*. Ignored if *autopct* is *None*. shadow : bool, optional, default: False Draw a shadow beneath the pie. labeldistance : float or None, optional, default: 1.1 The radial distance at which the pie labels are drawn. If set to ``None``, label are not drawn, but are stored for use in ``legend()`` startangle : float, optional, default: None If not *None*, rotates the start of the pie chart by *angle* degrees counterclockwise from the x-axis. radius : float, optional, default: None The radius of the pie, if *radius* is *None* it will be set to 1. counterclock : bool, optional, default: True Specify fractions direction, clockwise or counterclockwise. wedgeprops : dict, optional, default: None Dict of arguments passed to the wedge objects making the pie. For example, you can pass in ``wedgeprops = {'linewidth': 3}`` to set the width of the wedge border lines equal to 3. For more details, look at the doc/arguments of the wedge object. By default ``clip_on=False``. textprops : dict, optional, default: None Dict of arguments to pass to the text objects. center : list of float, optional, default: (0, 0) Center position of the chart. Takes value (0, 0) or is a sequence of 2 scalars. frame : bool, optional, default: False Plot axes frame with the chart if true. rotatelabels : bool, optional, default: False Rotate each label to the angle of the corresponding slice if true. Returns ------- patches : list A sequence of :class:`matplotlib.patches.Wedge` instances texts : list A list of the label :class:`matplotlib.text.Text` instances. autotexts : list A list of :class:`~matplotlib.text.Text` instances for the numeric labels. This will only be returned if the parameter *autopct* is not *None*. Notes ----- The pie chart will probably look best if the figure and axes are square, or the Axes aspect is equal. This method sets the aspect ratio of the axis to "equal". The axes aspect ratio can be controlled with `Axes.set_aspect`. �equalr r+ z�Non-1D inputs to pie() are currently squeeze()d, but this behavior is deprecated since %(since)s and will be removed %(removal)s; pass a 1D array instead.��messageNr� r z 'label' must be of length 'x'z 'explode' must be of length 'x'c s t � �S r )�nextr �Z color_cycler r r> � s z Axes.pie.<locals>.get_next_colorg �v@r� Frh rc rd g{�G�z��r: r0 r1 r2 r/ r� r~ r} � zxtick.labelsize)r? r> Zrotationr g Y@z+autopct must be callable or a format string)r? r> g �g �?).� set_aspectr r� Zfloat32r Zsqueezer� �warn_deprecatedrA �sumrU r9 r= r> rB rC r r� Zpi�mathZcosZsinrn ZWedger r r� rp � set_labelZShadowZ set_zorderZ get_zorderZrad2deg�dictr rA r� r r �callablerV Z set_frame_on�set_xlim�set_ylimZ set_xticks� set_yticks)(r- r rd rS r� ZautopctZ pctdistanceZshadowZ labeldistanceZ startangleZradiusZ counterclockZ wedgepropsZ textpropsr/ �frameZ rotatelabels�sxr> Ztheta1ZtextsZslicesZ autotexts�iZfracrB Zexplr� Ztheta2Zthetamr6 ZshadZxt�ytZlabel_alignment_hZlabel_alignment_vZlabel_rotationZpropsr� r� r rl r �pie, s� f � ��� �� �� � � zAxes.pier& r' c 6 K s� t �|tjj�}dd� |�� D �}|�dd� |dk r>td��| j|||d� |� � dk}|� d d �}|d krti }nd d� t d t |��D �}|dkr�|� d� d|ks�d|ks�|d k r�i }d|kr�|� d�|d< n t | jj�}d|d < |�|� d|k�rd|d< |d k�r|d }t�|��s&|g}t�|��s8|g}|d k �r\t�|��s\|gt|� }|d k �r�t�|��s�|gt|� }||d| �r�|d d n |d d i�}t|�}|� dd � |� dd � ||d< |�r�||d< nd|k�r�|d |d< dD ] }||k�r�|| ||< �q�t|�}|� dd � |� dd � |� dd � |� dd � |� dd � d|d< |d k�rvtd }|dk�r�d | |d < |d k �r�||d< d D ] }||k�r�|| ||< �q�||d< d }|�r�tj||f|�}| �|� g }g }t�| t|���t�} t�| t|���t�} t�| t|���t�} t�| t|���t�} t�t|��| dk} d d � } d!d"� } |d k �r�| ||�\} } | | B }!|!�� �s�t|!�dk�r2| || |!| @ �\}"}#| | | |!| @ �\}$}%|� | j |"|$|%f|�� |dk�r2|� tj|$|"fdd#i|��� |� tj|%|"fdd#i|��� | �� �r| || | | @ �\}"}#| || | | @ �\}$}%|� | j |"|$|%f|�� | | || | @ �\}&}'| � � �r�tj }(ntj }(|� tj|&|'fd$|(d%�|��� |dk�r| ||| | @ �\})}*|� tj|)|*fdd#i|��� | �� �r�| || | | @ �\}"}#| | || | @ �\}$}%|� | j |"|$|%f|�� | | || | @ �\}+}*| � � �rttj }(ntj }(|� tj|+|*fd$|(d%�|��� |dk�r�| ||| | @ �\},}'|� tj|,|'fdd#i|��� |d k �r:| ||�\}-}.| | B }/|/�� �st|/�dk�r�| ||-|/| @ �\}0}#| |-|.|/| @ �\}$}1|� | j!|0|$|1f|�� |dk�r�|� tj|0|$fdd&i|��� |� tj|0|1fdd&i|��� | �� �rh| ||-| | @ �\}0}#| ||.| | @ �\}$}1|� | j!|0|$|1f|�� | ||.| | @ �\},}2| �"� �rtj#}(ntj$}(|� tj|,|2fd$|(d%�|��� |dk�rh| ||| | @ �\})}*|� tj|)|*fdd&i|��� | �� �r:| ||-| | @ �\}0}#| |-|| | @ �\}$}1|� | j!|0|$|1f|�� | ||-| | @ �\})}3| �"� �r�tj$}(ntj#}(|� tj|)|3fd$|(d%�|��� |dk�r:| ||| | @ �\},}'|� tj|,|'fdd&i|��� |D ]}4| �|4� �q>| �%� t&|t'|�t'|�f|d k |d k |d'�}5| j(� |5� |5S )(a" Plot y versus x as lines and/or markers with attached errorbars. *x*, *y* define the data locations, *xerr*, *yerr* define the errorbar sizes. By default, this draws the data markers/lines as well the errorbars. Use fmt='none' to draw errorbars without any data markers. Parameters ---------- x, y : scalar or array-like The data positions. xerr, yerr : scalar or array-like, shape(N,) or shape(2,N), optional The errorbar sizes: - scalar: Symmetric +/- values for all data points. - shape(N,): Symmetric +/-values for each data point. - shape(2,N): Separate - and + values for each bar. First row contains the lower errors, the second row contains the upper errors. - *None*: No errorbar. Note that all error arrays should have *positive* values. See :doc:`/gallery/statistics/errorbar_features` for an example on the usage of ``xerr`` and ``yerr``. fmt : plot format string, optional, default: '' The format for the data points / data lines. See `.plot` for details. Use 'none' (case insensitive) to plot errorbars without any data markers. ecolor : mpl color, optional, default: None A matplotlib color arg which gives the color the errorbar lines. If None, use the color of the line connecting the markers. elinewidth : scalar, optional, default: None The linewidth of the errorbar lines. If None, the linewidth of the current style is used. capsize : scalar, optional, default: None The length of the error bar caps in points. If None, it will take the value from :rc:`errorbar.capsize`. capthick : scalar, optional, default: None An alias to the keyword argument *markeredgewidth* (a.k.a. *mew*). This setting is a more sensible name for the property that controls the thickness of the error bar cap in points. For backwards compatibility, if *mew* or *markeredgewidth* are given, then they will over-ride *capthick*. This may change in future releases. barsabove : bool, optional, default: False If True, will plot the errorbars above the plot symbols. Default is below. lolims, uplims, xlolims, xuplims : bool, optional, default: False These arguments can be used to indicate that a value gives only upper/lower limits. In that case a caret symbol is used to indicate this. *lims*-arguments may be of the same type as *xerr* and *yerr*. To use limits with inverted axes, :meth:`set_xlim` or :meth:`set_ylim` must be called before :meth:`errorbar`. errorevery : positive integer, optional, default: 1 Subsamples the errorbars. e.g., if errorevery=5, errorbars for every 5-th datapoint will be plotted. The data plot itself still shows all data points. Returns ------- container : :class:`~.container.ErrorbarContainer` The container contains: - plotline: :class:`~matplotlib.lines.Line2D` instance of x, y plot markers and/or line. - caplines: A tuple of :class:`~matplotlib.lines.Line2D` instances of the error bar caps. - barlinecols: A tuple of :class:`~matplotlib.collections.LineCollection` with the horizontal and vertical error ranges. Other Parameters ---------------- **kwargs All other keyword arguments are passed on to the plot command for the markers. For example, this code makes big red squares with thick green edges:: x,y,yerr = rand(3,10) errorbar(x, y, yerr, marker='s', mfc='red', mec='green', ms=20, mew=4) where *mfc*, *mec*, *ms* and *mew* are aliases for the longer property names, *markerfacecolor*, *markeredgecolor*, *markersize* and *markeredgewidth*. Valid kwargs for the marker properties are `.Lines2D` properties: %(_Line2D_docstr)s c S s i | ]\}}|d k r||�qS r r �r� r� �vr r r r� � s z!Axes.errorbar.<locals>.<dictcomp>r] rh r z0errorevery has to be a strictly positive integerr� rb rB Nr� c S s i | ]\}}|d k r||�qS r r r} r r r r� � s � �r� r r� r� r0 r\ 皙�����?r r� r� )r\ rf r] � rasterized�markerfacecolor�markeredgewidth�markeredgecolor�lsr, r � @� markersize)r� r\ rf r] r� c S sX t | �t |�kst�t | �t |�ks(t�dd� t| |�D �} dd� t||�D �}| |fS )zo return xs[mask], ys[mask] where mask is True but xs and ys are not arrays c S s g | ]\}}|r|�qS r r )r� r� r r r r r� s z2Axes.errorbar.<locals>.xywhere.<locals>.<listcomp>c S s g | ]\}}|r|�qS r r )r� r� r r r r r� s )rU r r� )�xs�ys�maskr r r �xywhere� s z Axes.errorbar.<locals>.xywherec S s4 z | \}}t |� t |� W n ttfk r< | }}Y nX t�|�}t�|�}t|�dks�t|�dkrv|d dks�t|�dks�t|�dkr�|d dkr�td��t|�dks�t|�dkr�tjddd� ||fD ]2}t|�t|�kr�tdt|�� dt|�� d ���q�d d � t||�D �}d d � t||�D �}||fS ) z� Private function to parse *err* and subtract/add it to *data*. Both *err* and *data* are already iterables at this point. rh r z1err must be a scalar or a 1D or (2, n) array-liker+ z�Support for passing a (n, 1)-shaped error array to errorbar() is deprecated since Matplotlib %(since)s and will be removed %(removal)s; pass a 1D array instead.ri zThe lengths of the data (z) and the error z do not matchc S s g | ]\}}|| �qS r r �r� r~ rN r r r r� ) s z6Axes.errorbar.<locals>.extract_err.<locals>.<listcomp>c S s g | ]\}}|| �qS r r r� r r r r� * s ) �iterrV r9 r r� rU r� ro r� ) �errrj r� r Za_shZb_shrN ZlowZhighr r r � extract_err s> $ � � �� � �z"Axes.errorbar.<locals>.extract_err�|r )r� r �_)Zhas_xerrZhas_yerrrB ))r� r� r� r� r� �itemsr r9 r� r7 r_ r� r rk r� Z prop_cyclerrA r r� rU rs r r� rM �astype�boolr r� r� r� Zxaxis_invertedZ CARETLEFTBASEZCARETRIGHTBASEr� Zyaxis_invertedZ CARETDOWNBASEZ CARETUPBASEr� r �tupleZ containers)6r- r r� r' r& r� r* Z elinewidthr+ Z barsaboveZlolimsZuplimsZxlolimsZxuplimsZ erroreveryZcapthickrD Z plot_linerB Zfmt_style_kwargsZ base_styleZplot_line_styleZeb_lines_style�keyZ eb_cap_styleZ data_lineZbarcolsZcaplinesZ everymaskr� r� r1 r2 ZnoxlimsZyor� �loZroZrightupZyupr ZxloZyloZleftloZxupr7 �upperZnoylimsZxoZuoZupperupZlowerlor� Zerrorbar_containerr r r rI s� o � �� � � $ �� �� � �� � �� �� � �� � �� z Axes.errorbarZ manage_xticks� manage_ticksc $ C s� |dkrt d }| dkr t d } tj||| ||d�}|dkrDt d }|dkrTt d }|dkrdt d }| dkrtt d } | dkr�t d } |dkr�t d }|dkr�t d }|dkr�t d }|dkr�i }|dkr�i }|dkr�i }|dkr�i }|dkr�i }|dkr�i }|�r"d |d< d|k�r"|�d�|d< |dk �r�|dk�rJtdddd�}d}nBt|�\} } } | dk �rj| |d< | dk �r�| |d< | |d< | |d< | dk �r�tt�| ��t|�k�s�t� | �d t|�k�r�t d��n(t || �D ] \} } | dk �r�| | d< �q�| dk �r�t� | �d t|�k�r(d}!t |!��nlt || �D ]`\} }"|"dk �r2t|"�d k�r\t d ��n4|"d dk �rv|"d | d < |"d dk �r2|"d | d < �q2| j ||||||| ||||||| |||||d!�}#|#S )"a� Make a box and whisker plot. Make a box and whisker plot for each column of ``x`` or each vector in sequence ``x``. The box extends from the lower to upper quartile values of the data, with a line at the median. The whiskers extend from the box to show the range of the data. Flier points are those past the end of the whiskers. Parameters ---------- x : Array or a sequence of vectors. The input data. notch : bool, optional (False) If `True`, will produce a notched box plot. Otherwise, a rectangular boxplot is produced. The notches represent the confidence interval (CI) around the median. See the entry for the ``bootstrap`` parameter for information regarding how the locations of the notches are computed. .. note:: In cases where the values of the CI are less than the lower quartile or greater than the upper quartile, the notches will extend beyond the box, giving it a distinctive "flipped" appearance. This is expected behavior and consistent with other statistical visualization packages. sym : str, optional The default symbol for flier points. Enter an empty string ('') if you don't want to show fliers. If `None`, then the fliers default to 'b+' If you want more control use the flierprops kwarg. vert : bool, optional (True) If `True` (default), makes the boxes vertical. If `False`, everything is drawn horizontally. whis : float, sequence, or string (default = 1.5) As a float, determines the reach of the whiskers to the beyond the first and third quartiles. In other words, where IQR is the interquartile range (`Q3-Q1`), the upper whisker will extend to last datum less than `Q3 + whis*IQR`). Similarly, the lower whisker will extend to the first datum greater than `Q1 - whis*IQR`. Beyond the whiskers, data are considered outliers and are plotted as individual points. Set this to an unreasonably high value to force the whiskers to show the min and max values. Alternatively, set this to an ascending sequence of percentile (e.g., [5, 95]) to set the whiskers at specific percentiles of the data. Finally, ``whis`` can be the string ``'range'`` to force the whiskers to the min and max of the data. bootstrap : int, optional Specifies whether to bootstrap the confidence intervals around the median for notched boxplots. If ``bootstrap`` is None, no bootstrapping is performed, and notches are calculated using a Gaussian-based asymptotic approximation (see McGill, R., Tukey, J.W., and Larsen, W.A., 1978, and Kendall and Stuart, 1967). Otherwise, bootstrap specifies the number of times to bootstrap the median to determine its 95% confidence intervals. Values between 1000 and 10000 are recommended. usermedians : array-like, optional An array or sequence whose first dimension (or length) is compatible with ``x``. This overrides the medians computed by matplotlib for each element of ``usermedians`` that is not `None`. When an element of ``usermedians`` is None, the median will be computed by matplotlib as normal. conf_intervals : array-like, optional Array or sequence whose first dimension (or length) is compatible with ``x`` and whose second dimension is 2. When the an element of ``conf_intervals`` is not None, the notch locations computed by matplotlib are overridden (provided ``notch`` is `True`). When an element of ``conf_intervals`` is `None`, the notches are computed by the method specified by the other kwargs (e.g., ``bootstrap``). positions : array-like, optional Sets the positions of the boxes. The ticks and limits are automatically set to match the positions. Defaults to `range(1, N+1)` where N is the number of boxes to be drawn. widths : scalar or array-like Sets the width of each box either with a scalar or a sequence. The default is 0.5, or ``0.15*(distance between extreme positions)``, if that is smaller. patch_artist : bool, optional (False) If `False` produces boxes with the Line2D artist. Otherwise, boxes and drawn with Patch artists. labels : sequence, optional Labels for each dataset. Length must be compatible with dimensions of ``x``. manage_ticks : bool, optional (True) If True, the tick locations and labels will be adjusted to match the boxplot positions. autorange : bool, optional (False) When `True` and the data are distributed such that the 25th and 75th percentiles are equal, ``whis`` is set to ``'range'`` such that the whisker ends are at the minimum and maximum of the data. meanline : bool, optional (False) If `True` (and ``showmeans`` is `True`), will try to render the mean as a line spanning the full width of the box according to ``meanprops`` (see below). Not recommended if ``shownotches`` is also True. Otherwise, means will be shown as points. zorder : scalar, optional (None) Sets the zorder of the boxplot. Other Parameters ---------------- showcaps : bool, optional (True) Show the caps on the ends of whiskers. showbox : bool, optional (True) Show the central box. showfliers : bool, optional (True) Show the outliers beyond the caps. showmeans : bool, optional (False) Show the arithmetic means. capprops : dict, optional (None) Specifies the style of the caps. boxprops : dict, optional (None) Specifies the style of the box. whiskerprops : dict, optional (None) Specifies the style of the whiskers. flierprops : dict, optional (None) Specifies the style of the fliers. medianprops : dict, optional (None) Specifies the style of the median. meanprops : dict, optional (None) Specifies the style of the mean. Returns ------- result : dict A dictionary mapping each component of the boxplot to a list of the :class:`matplotlib.lines.Line2D` instances created. That dictionary has the following keys (assuming vertical boxplots): - ``boxes``: the main body of the boxplot showing the quartiles and the median's confidence intervals if enabled. - ``medians``: horizontal lines at the median of each box. - ``whiskers``: the vertical lines extending to the most extreme, non-outlier data points. - ``caps``: the horizontal lines at the ends of the whiskers. - ``fliers``: points representing data that extend beyond the whiskers (fliers). - ``means``: points or lines representing the means. Nzboxplot.whiskerszboxplot.bootstrap)�whis� bootstraprS � autorangez boxplot.notchzboxplot.verticalzboxplot.patchartistzboxplot.meanlinezboxplot.showmeanszboxplot.showcapszboxplot.showboxzboxplot.showfliersr� r� r� re r� rb r Fr r� r� r z(usermedians length not compatible with x�medz+conf_intervals length not compatible with xrh z-each confidence interval must have two values�cilor �cihi)r� �widths�vert� patch_artist� shownotches� showmeans�showcaps�showbox�boxprops� flierprops� medianprops� meanprops�meanline� showfliers�capprops� whiskerpropsr� r] ) r r� Z boxplot_statsr_ rs r rU r r� r� r9 r� �bxp)$r- r ZnotchZsymr� r� r� r� r� r� Z usermediansZconf_intervalsr� r� r� r� r� r� rS r� r� r� r� r� r� r� r] �bxpstatsr� r r� �statsr� Zerr_messZci�artistsr r r �boxplot� s� 5 � � � z Axes.boxplotc B s g }g }g }g }g }g }g }�dkr,t jj�d}d:�fdd� } |r�ttd td td td rbd ntd �d �} | dk r�| �t�| tj j �� n | d | �} | d| �} | d|�} | d| �} | d||�}!| d||�}"|r�dnd}#|dks�|#|kr�d|"|#< dd� ���fdd�� |�r*�fdd�}$� fd d �}%n�fd d�}$� fd d �}%t |�}&d }'|dk�rlt t d!|&d! ��}n t |�|&k�r�t|'�d"���t�|�}t |�dk�r�t|d t��s�td#��|dk�r�t�d$t�|� d$d%�g|& }n4t�|��r�|g|& }n t |�|&k�rt|'�d&���t|||�D �]�\}(})}*|�|*�d'|(�� t�d(�|( }+t�|*d) |*d* g�},t�|*d+ |*d, g�}-|(|)d- }.|(|)d- }/t�|.|/g�}0t�d(�|*d* }1t�d(�|*d, }2|(|)d% }3|(|)d% }4|*d. |*d. g}5|�rX|3|4|4|/|4|4|3|3|.|3|3g }6|*d) |*d) |*d/ |*d. |*d0 |*d+ |*d+ |*d0 |*d. |*d/ |*d) g }7|0}8n8|3|4|4|3|3g}6|*d) |*d) |*d+ |*d+ |*d) g}7|3|4g}8| �r�|�r�|� |%|6|7f| �� n|� |$|6|7f| �� |� |$|+|,f| �� |� |$|+|-f| �� |�r |� |$|0|1f| �� |� |$|0|2f| �� |� |$|8|5f|!�� |�r~|�rb|� |$|3|4g|*d1 |*d1 gf|"�� n |� |$|(g|*d1 gf|"�� | �r"tj t |*d2 �|(tj d3�}9|*d2 }:|� |$|9|:f| �� �q"|�r�|�r�d4nd5};t �j d6|;� ��}<t �|;� d7��}=|=�!|�}t"|<d t"|�d% �t#|<d! t#|�d% �f|<dd�< t||�D ](\}>}?t |>j$|;�� |?d% |?d% g� �q<|=�%� }@t|=�%� t&j'��s�t&�'g �}@|=�(|@� t�|@j)|��|@_)|=�*� }At|=�*� t&j+��s�t&�+g �}A|=�,|A� |Aj-|�|A_-�j.�j/�j0d8� t||||||d9�S );a Drawing function for box and whisker plots. Make a box and whisker plot for each column of *x* or each vector in sequence *x*. The box extends from the lower to upper quartile values of the data, with a line at the median. The whiskers extend from the box to show the range of the data. Flier points are those past the end of the whiskers. Parameters ---------- bxpstats : list of dicts A list of dictionaries containing stats for each boxplot. Required keys are: - ``med``: The median (scalar float). - ``q1``: The first quartile (25th percentile) (scalar float). - ``q3``: The third quartile (75th percentile) (scalar float). - ``whislo``: Lower bound of the lower whisker (scalar float). - ``whishi``: Upper bound of the upper whisker (scalar float). Optional keys are: - ``mean``: The mean (scalar float). Needed if ``showmeans=True``. - ``fliers``: Data beyond the whiskers (sequence of floats). Needed if ``showfliers=True``. - ``cilo`` & ``cihi``: Lower and upper confidence intervals about the median. Needed if ``shownotches=True``. - ``label``: Name of the dataset (string). If available, this will be used a tick label for the boxplot positions : array-like, default = [1, 2, ..., n] Sets the positions of the boxes. The ticks and limits are automatically set to match the positions. widths : array-like, default = None Either a scalar or a vector and sets the width of each box. The default is ``0.15*(distance between extreme positions)``, clipped to no less than 0.15 and no more than 0.5. vert : bool, default = True If `True` (default), makes the boxes vertical. If `False`, makes horizontal boxes. patch_artist : bool, default = False If `False` produces boxes with the `~matplotlib.lines.Line2D` artist. If `True` produces boxes with the `~matplotlib.patches.Patch` artist. shownotches : bool, default = False If `False` (default), produces a rectangular box plot. If `True`, will produce a notched box plot showmeans : bool, default = False If `True`, will toggle on the rendering of the means showcaps : bool, default = True If `True`, will toggle on the rendering of the caps showbox : bool, default = True If `True`, will toggle on the rendering of the box showfliers : bool, default = True If `True`, will toggle on the rendering of the fliers boxprops : dict or None (default) If provided, will set the plotting style of the boxes whiskerprops : dict or None (default) If provided, will set the plotting style of the whiskers capprops : dict or None (default) If provided, will set the plotting style of the caps flierprops : dict or None (default) If provided will set the plotting style of the fliers medianprops : dict or None (default) If provided, will set the plotting style of the medians meanprops : dict or None (default) If provided, will set the plotting style of the means meanline : bool, default = False If `True` (and *showmeans* is `True`), will try to render the mean as a line spanning the full width of the box according to *meanprops*. Not recommended if *shownotches* is also True. Otherwise, means will be shown as points. manage_ticks : bool, default = True If True, the tick locations and labels will be adjusted to match the boxplot positions. zorder : scalar, default = None The zorder of the resulting boxplot. Returns ------- result : dict A dictionary mapping each component of the boxplot to a list of the :class:`matplotlib.lines.Line2D` instances created. That dictionary has the following keys (assuming vertical boxplots): - ``boxes``: the main body of the boxplot showing the quartiles and the median's confidence intervals if enabled. - ``medians``: horizontal lines at the median of each box. - ``whiskers``: the vertical lines extending to the most extreme, non-outlier data points. - ``caps``: the horizontal lines at the ends of the whiskers. - ``fliers``: points representing data that extend beyond the whiskers (fliers). - ``means``: points or lines representing the means. Examples -------- .. plot:: gallery/statistics/bxp.py Nr� r c sD � fdd�t �� D �}�| |d< |d k r@|�t�|tjj�� |S )Nc s0 i | ](\}}|� d � � ��r|�d�d |�qS )zboxplot.�.rl )� startswith�splitr} ��subkeyr r r� d s � z@Axes.bxp.<locals>.line_props_with_rcdefaults.<locals>.<dictcomp>r] )r r� rA r� r� r� r� r� )r� Zexplicit�zdeltar )r] r� r �line_props_with_rcdefaultsc s �z,Axes.bxp.<locals>.line_props_with_rcdefaultszboxplot.boxprops.linestylezboxplot.boxprops.linewidthzboxplot.boxprops.colorr] Zwhitezpatch.facecolor)r� r� re rd r] r� r� r� r� r� r� r r� r� c S sL t �t �| |g�dgd�}tjjgtjjgt|�d tjjg }||fS )Nrg r rh ) r r� � column_stack�mpath�PathZMOVETOZLINETOrU Z CLOSEPOLY)r� r� r� �codesr r r �to_vc� s ��zAxes.bxp.<locals>.to_vcc s8 �| |�\}}t �||�}tj|f|�}� �|� |gS r )r� r� rn � PathPatch� add_artist)r� r� rD r� r� �pathr� )r- r� r r � patch_list� s z Axes.bxp.<locals>.patch_listc s � j | |�S r )r� )rY rD r, r r �doplot� s zAxes.bxp.<locals>.doplotc s � | |f|�S r r �r� r� rD �r� r r �dopatch� s zAxes.bxp.<locals>.dopatchc s@ g }t dt| �d�D ] }|�| |d | | g� q� j||�S )Nr rh r )r rU �extendr� )rY rD Zshuffledrz r, r r r� � s c s || } }� | |f|�S r r r� r� r r r� � s zEList of boxplot statistics and `{0}` values must have same the lengthr r� z*positions should be an iterable of numbersg333333�?rc r� rB rh Zq1ZwhisloZq3Zwhishi� �?r� r� r� �mean�fliersr[ r r� �interval�axisr� )�whiskers�caps�boxes�mediansr� �means)r )1r� r� r] rs r rA r� r� rn r� r� rU r� r r9 ra r �arrayr r rV r- �ptp�isscalarr� r� r? �onesr� r �float64�getattrrJ Z convert_unitsr r rH Zget_major_locator�mtickerZ FixedLocator�set_major_locatorZlocsZget_major_formatterZFixedFormatterZset_major_formatter�seqr� Z _autoscaleXonZ _autoscaleYon)Br- r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r] r� r� r� r� r� r� Z datalabelsr� r� Zfinal_boxpropsZfinal_whiskerpropsZfinal_cappropsZfinal_flierpropsZfinal_medianpropsZfinal_meanpropsZ removed_propr� r� �N�datashape_messagerz r1 r� Z whisker_xZ whiskerlo_yZ whiskerhi_yZcap_leftZ cap_rightZcap_xZcap_loZcap_hiZbox_leftZ box_rightZmed_yZbox_xZbox_yZmed_xZflier_xZflier_yZ axis_namer� r� �medianr� ZlocatorZ formatterr )r� r- r� r] r r� � s� � �� � � � � � � �� �� �� �� �� �� � �� � � �zAxes.bxpc C s\ t �tj|d�}t �tj|d�}|�dd�}|�d|�}|�d|�}|�dd�} | dk rh| dk rhtd��| dk r�zt�| � W n tk r� td��Y nX |dkr�| }|dkr�| }|dkr�td s�td }| dk} | dkr�|dk r�|ntd r�d n|� } d } d } | �sN| dk �sNt | t ��sNt | t j j ��rTt| �dk�rTt t�| �t ��rTd} ntzXtj| td�} | jd } | j||fk�r�tj�| �} n | jdk�r�t�d� d} d} W n tk �r� d} Y nX | dk�rNz8t�| �}|jd } |jd dd||fk�rd} t�W n@ tk �rJ | �s8tdj| ||d���ntd�| ���Y nX nd}| ||fS )a Helper function to process color related arguments of `.Axes.scatter`. Argument precedence for facecolors: - c (if not None) - kwargs['facecolors'] - kwargs['facecolor'] - kwargs['color'] (==kwcolor) - 'b' if in classic mode else the result of ``get_next_color_func()`` Argument precedence for edgecolors: - edgecolors (is an explicit kw argument in scatter()) - kwargs['edgecolor'] - kwargs['color'] (==kwcolor) - 'face' if not in classic mode else None Parameters ---------- c : color or sequence or sequence of color or None See argument description of `.Axes.scatter`. edgecolors : color or sequence of color or {'face', 'none'} or None See argument description of `.Axes.scatter`. kwargs : dict Additional kwargs. If these keys exist, we pop and process them: 'facecolors', 'facecolor', 'edgecolor', 'color' Note: The dict is modified by this function. xshape, yshape : tuple of int The shape of the x and y arrays passed to `.Axes.scatter`. get_next_color_func : callable A callable that returns a color. This color is used as facecolor if no other color is provided. Note, that this is a function rather than a fixed color value to support conditional evaluation of the next color. As of the current implementation obtaining the next color from the property cycle advances the cycle. This must only happen if we actually use the color, which will only be decided within this method. Returns ------- c The input *c* if it was not *None*, else some color specification derived from the other inputs or defaults. colors : array(N, 4) or None The facecolors as RGBA values or *None* if a colormap is used. edgecolors The edgecolor specification. r � facecolorsNrd re r� zeSupply a 'c' argument or a 'color' kwarg but not both; they differ but their functionalities overlap.z�'color' kwarg must be an mpl color spec or sequence of color specs. For a sequence of values to be color-mapped, use the 'c' argument instead.r] zscatter.edgecolorsr Trl r r[ ))ri )� a 'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'. Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.Fzl'c' argument has {nc} elements, which is not acceptable for use with 'x' with size {xs}, 'y' with size {ys}.)�ncr� r� z\'c' argument must be a mpl color, a sequence of mpl colors or a sequence of numbers, not {}.)� functools�reduce�operator�mulr_ r9 r� r� r r r � collections�abc�IterablerU r� r r r� r@ r� r r� �_logZwarningra )rP � edgecolorsrD �xshape�yshape�get_next_color_funcZxsizeZysizer� ZkwcolorZ c_was_noneZ valid_shapeZn_elemZc_arrayr� r r r �_parse_scatter_color_args; s� 7 � �� � �� � �� �� z Axes._parse_scatter_color_argsr� r� rP rd r� r� )� plotnonfinitec K s� | j |||d� | �|�}| �|�}t�|�t�|� }}tj�|�}tj�|�}|j|jkrftd��|dkr�t d rzdn t d d }tj�|�}| j || |||| j j d�\}}} |r�|dkr�tj� |�}t�|||| | �\}}}} } n$t�|||||| | �\}}}}}} } |}| dk �r:tjd d d d d � |dk�r:| }|dk�rLt d }t|tj��r`|}n t�|�}|�� �|�� �}|�� �s�d} t d } tj�||g�}tj|f||| | ||�d| j �| d�}|� t � � � |� |� |dk�rR|dk �r t|t!j"��s td��|�#|� |�$|� |�%|� |dk �s<| dk �rJ|�&|| � n|�'� t d �r�| j(dk �r~|jdk�r~| �)d� | j*dk �r�|jdk�r�| �+d� | �,|� | �-� |S )a� A scatter plot of *y* vs *x* with varying marker size and/or color. Parameters ---------- x, y : array_like, shape (n, ) The data positions. s : scalar or array_like, shape (n, ), optional The marker size in points**2. Default is ``rcParams['lines.markersize'] ** 2``. c : color, sequence, or sequence of color, optional The marker color. Possible values: - A single color format string. - A sequence of color specifications of length n. - A sequence of n numbers to be mapped to colors using *cmap* and *norm*. - A 2-D array in which the rows are RGB or RGBA. Note that *c* should not be a single numeric RGB or RGBA sequence because that is indistinguishable from an array of values to be colormapped. If you want to specify the same RGB or RGBA value for all points, use a 2-D array with a single row. Otherwise, value- matching will have precedence in case of a size matching with *x* and *y*. Defaults to ``None``. In that case the marker color is determined by the value of ``color``, ``facecolor`` or ``facecolors``. In case those are not specified or ``None``, the marker color is determined by the next color of the ``Axes``' current "shape and fill" color cycle. This cycle defaults to :rc:`axes.prop_cycle`. marker : `~matplotlib.markers.MarkerStyle`, optional The marker style. *marker* can be either an instance of the class or the text shorthand for a particular marker. Defaults to ``None``, in which case it takes the value of :rc:`scatter.marker` = 'o'. See `~matplotlib.markers` for more information about marker styles. cmap : `~matplotlib.colors.Colormap`, optional, default: None A `.Colormap` instance or registered colormap name. *cmap* is only used if *c* is an array of floats. If ``None``, defaults to rc ``image.cmap``. norm : `~matplotlib.colors.Normalize`, optional, default: None A `.Normalize` instance is used to scale luminance data to 0, 1. *norm* is only used if *c* is an array of floats. If *None*, use the default `.colors.Normalize`. vmin, vmax : scalar, optional, default: None *vmin* and *vmax* are used in conjunction with *norm* to normalize luminance data. If None, the respective min and max of the color array is used. *vmin* and *vmax* are ignored if you pass a *norm* instance. alpha : scalar, optional, default: None The alpha blending value, between 0 (transparent) and 1 (opaque). linewidths : scalar or array_like, optional, default: None The linewidth of the marker edges. Note: The default *edgecolors* is 'face'. You may want to change this as well. If *None*, defaults to rcParams ``lines.linewidth``. edgecolors : {'face', 'none', *None*} or color or sequence of color, optional. The edge color of the marker. Possible values: - 'face': The edge color will always be the same as the face color. - 'none': No patch boundary will be drawn. - A Matplotlib color or sequence of color. Defaults to ``None``, in which case it takes the value of :rc:`scatter.edgecolors` = 'face'. For non-filled markers, the *edgecolors* kwarg is ignored and forced to 'face' internally. plotnonfinite : boolean, optional, default: False Set to plot points with nonfinite *c*, in conjunction with `~matplotlib.colors.Colormap.set_bad`. Returns ------- paths : `~matplotlib.collections.PathCollection` Other Parameters ---------------- **kwargs : `~matplotlib.collections.Collection` properties See Also -------- plot : To plot scatter plots when markers are identical in size and color. Notes ----- * The `.plot` function will be faster for scatterplots where markers don't vary in size or color. * Any or all of *x*, *y*, *s*, and *c* may be masked arrays, in which case all masks will be combined and only unmasked points will be plotted. * Fundamentally, scatter works with 1-D arrays; *x*, *y*, *s*, and *c* may be input as 2-D arrays, but within scatter they will be flattened. The exception is *c*, which will be flattened only if its size matches the size of *x* and *y*. r� z x and y must be the same sizeNr] � zlines.markersizer� )r� z3.0z'verts'�kwargz'marker')�name�obj_type� alternativezscatter.marker�facezlines.linewidthr\ )r� r� r� �offsets� transOffsetrf �1'norm' must be an instance of 'mcolors.Normalize'皙�����?r ).r� r� r� r r� r r� r r9 r r� r= r> �masked_invalidr� Z_combine_masksro r �mmarkersZ MarkerStylerG rq Z get_transformZ is_filledr� r� ZPathCollectionr_ rm r� r r� rA r� � Normalize� set_array�set_cmap�set_norm�set_clim�autoscale_NoneZ_xmarginZ set_xmarginZ_ymarginZ set_ymarginr� r� )r- r r� r� rP r �cmap�norm�vmin�vmaxrf r� r� r� r� rD r� r� r� ZscalesZ marker_objr� r� � collectionr r r �scatter� s� z � �� � �� � � � � z Axes.scatterr3 �linearr� c J s� | j |||d� t�|||�\}}}t�|�r8|\}}n|}t|t�d� �}t�|t �}t�|t �}|dkr�t� |dk�r�t d��t� |�}|dkr�t� |dk�r�t d��t� |�}|dk r�|\}}}}nrt |�r�t�|�t�|�fnd\}}t |��rt�|�t�|�fnd\}}tj||d d �\}}tj||d d �\}}d || }||8 }||7 }|| | }|| | } |�r�|�� } |�� } || | }|| | }t�|��t�} t�|��t�} t�|��t�}!t�|��t�}"|d }#|d }$|}%|}&|#|$ |%|& }'|| d d|| d }(||! d d d||" d d })|(|)k }*|dk�r�t�|#|$f�}+t�|%|&f�},d| k| |#k d| k | |$k }-d|!k|!|%k d|"k |"|&k }.|-|*9 }-|.t�|*�9 }.| |- | |- } } |!|. |"|. }!}"t| | �D ] \}/}0|+|/|0f d 7 < �q�t|!|"�D ] \}/}0|,|/|0f d 7 < �q$|dk �rjtj|+|+|k < tj|,|,|k < t�|+�� |,�� f�}1t� |1� }2�nH|dk�r�d}tj |#|$ft d�}+t |#�D ]"}3t |$�D ]}4g |+|3|4f< �qĐq�tj |%|&ft d�},t |%�D ]"}3t |&�D ]}4g |,|3|4f< �q�q�t t |��D ]�}3|*|3 �r�d| |3 k�rP|#k �r�n n>d| |3 k�rp|$k �r�n n |+| |3 | |3 f � ||3 � n^d|!|3 k�r�|%k �r&n n>d|"|3 k�r�|&k �r&n n |,|!|3 |"|3 f � ||3 � �q&t |#�D ]P}3t |$�D ]@}4|+|3|4f }5t |5�|k�r:�|5�|+|3|4f< ntj|+|3|4f< �q �q�t |%�D ]P}3t |&�D ]@}4|,|3|4f }5t |5�|k�r��|5�|,|3|4f< ntj|,|3|4f< �qd�qXt�|+�t ��� |,�t ��� f�}1t� |1� }2t�|'d ft �}6t�!t�"|#�|$�|6d|#|$ �df< t�#t�"|$�|#�|6d|#|$ �d f< t�!t�"|%�d |&�|6|#|$ d�df< t�#t�"|&�|%�d |6|#|$ d�d f< |6dd�df |9 < |6dd�d f | 9 < |6dd�df |7 < |6dd�d f |7 < |6|2dd�f }6|1|2 }1t�dt �}7|t�ddddddg� |7dd�df< | t�ddddddg� d |7dd�d f< |dk�r\dg}|dk�sp|dk�r:t�$|7d�t�$|6d � }8|dk�r�d|8dd�dd�df |8dd�dd�df< d| }d| }| �%|� |dk�r(d|8dd�dd�d f |8dd�dd�d f< d| }d| }| �&|� t'j(|8||d�}9n t'j(|7g|||6t�)� dd�}9| dk �rzt*| t+j,��szd}:t |:��|dk�r�| dk �r�t�-d�.|�� nt+�/� } d}t*| t+j/��r�|1dk� � �r�|1d 7 }1| dk �r�| j0dk�r�| j1dk�r�| �2|1� |dk � rZt�|�� sFt|1�t|1� };}<|d 8 }|;|<|; t�"|� | }t�3|�}|�4|1�}1|9�5|1� |9�6| � |9�7| � |9�8| � |9�9|� | dk � s�| dk � r�|9�:| | � n|9�;� ||f||ff}=| �<|=� ||g|9j=j>dd�< ||g|9j=j?dd�< | j@d d � | jA|9d d � |� s |9S |dk� r4t�Bt |��}�fd d!�}>t�C|||�}?|>| ||?�}@t� |@� }Ag g }B}CtD|@�D ]~\}3}D|?|3 }E|3t |?�d k � r�|?|3d }Fn|Et�E|?�d" }F|A|3 � sȐ qx|B� |Edf|Ed#f|Fd#f|Fdfg� |C� |D� � qxt�|C�}C| jFd$d%�}Gt'j(|B|Gd&d'�� � �5|C� � �6| � � �7| � � �8| � � �9|� | jA� d d � t�C|||�}?|>| ||?�}Ht� |H� }Ag g }B}CtD|H�D ]~\}3}D|?|3 }E|3t |?�d k � r�|?|3d }Fn|Et�E|?�d" }F|A|3 � s� q�|B� d|Efd|Ffd#|Ffd#|Efg� |C� |D� � q�t�|C�}C| jGd$d%�}Gt'j(|B|Gd&d'����5|C� ��6| � ��7| � ��8| � ��9|� | jA�d d � � |9_H�|9_I� �fd(d)�}I|9jJ�Kd*|I� |9S )+a� Make a 2D hexagonal binning plot of points *x*, *y*. If *C* is *None*, the value of the hexagon is determined by the number of points in the hexagon. Otherwise, *C* specifies values at the coordinate (x[i], y[i]). For each hexagon, these values are reduced using *reduce_C_function*. Parameters ---------- x, y : array-like The data positions. *x* and *y* must be of the same length. C : array-like, optional If given, these values are accumulated in the bins. Otherwise, every point has a value of 1. Must be of the same length as *x* and *y*. gridsize : int or (int, int), default: 100 If a single int, the number of hexagons in the *x*-direction. The number of hexagons in the *y*-direction is chosen such that the hexagons are approximately regular. Alternatively, if a tuple (*nx*, *ny*), the number of hexagons in the *x*-direction and the *y*-direction. bins : 'log' or int or sequence, default: *None* Discretization of the hexagon values. - If *None*, no binning is applied; the color of each hexagon directly corresponds to its count value. - If 'log', use a logarithmic scale for the color map. Internally, :math:`log_{10}(i+1)` is used to determine the hexagon color. This is equivalent to ``norm=LogNorm()``. - If an integer, divide the counts in the specified number of bins, and color the hexagons accordingly. - If a sequence of values, the values of the lower bound of the bins to be used. xscale : {'linear', 'log'}, default: 'linear' Use a linear or log10 scale on the horizontal axis. yscale : {'linear', 'log'}, default: 'linear' Use a linear or log10 scale on the vertical axis. mincnt : int > 0, default: *None* If not *None*, only display cells with more than *mincnt* number of points in the cell. marginals : bool, default: *False* If marginals is *True*, plot the marginal density as colormapped rectangles along the bottom of the x-axis and left of the y-axis. extent : float, default: *None* The limits of the bins. The default assigns the limits based on *gridsize*, *x*, *y*, *xscale* and *yscale*. If *xscale* or *yscale* is set to 'log', the limits are expected to be the exponent for a power of 10. E.g. for x-limits of 1 and 50 in 'linear' scale and y-limits of 10 and 1000 in 'log' scale, enter (1, 50, 1, 3). Order of scalars is (left, right, bottom, top). Other Parameters ---------------- cmap : str or `~matplotlib.colors.Colormap`, optional The Colormap instance or registered colormap name used to map the bin values to colors. Defaults to :rc:`image.cmap`. norm : `~matplotlib.colors.Normalize`, optional The Normalize instance scales the bin values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling. vmin, vmax : float, optional, default: None The colorbar range. If *None*, suitable min/max values are automatically chosen by the `~.Normalize` instance (defaults to the respective min/max values of the bins in case of the default linear scaling). This is ignored if *norm* is given. alpha : float between 0 and 1, optional The alpha blending value, between 0 (transparent) and 1 (opaque). linewidths : float, default: *None* If *None*, defaults to 1.0. edgecolors : {'face', 'none', *None*} or color, default: 'face' The color of the hexagon edges. Possible values are: - 'face': Draw the edges in the same color as the fill color. - 'none': No edges are drawn. This can sometimes lead to unsightly unpainted pixels between the hexagons. - *None*: Draw outlines in the default color. - An explicit matplotlib color. reduce_C_function : callable, default is `numpy.mean` The function to aggregate *C* within the bins. It is ignored if *C* is not given. This must have the signature:: def reduce_C_function(C: array) -> float Commonly used functions are: - `numpy.mean`: average of the points - `numpy.sum`: integral of the point values - `numpy.max`: value taken from the largest point **kwargs : `~matplotlib.collections.PolyCollection` properties All other keyword arguments are passed on to `.PolyCollection`: %(PolyCollection)s Returns ------- polycollection : `~matplotlib.collections.PolyCollection` A `.PolyCollection` defining the hexagonal bins. - `.PolyCollection.get_offset` contains a Mx2 array containing the x, y positions of the M hexagon centers. - `.PolyCollection.get_array` contains the values of the M hexagons. If *marginals* is *True*, horizontal bar and vertical bar (both PolyCollections) will be attached to the return collection as attributes *hbar* and *vbar*. r� ri r� � z8x contains non-positive values, so can not be log-scaledz8y contains non-positive values, so can not be log-scaledN)r r r� )Zexpanderg��&� .>r rh g @rc r r[ )� rh � �� �?g �� $@)r� r� rj )r� r� r� r� Zoffset_positionr� zIOnly one of 'bins' and 'norm' arguments can be supplied, ignoring bins={}T�ZtightFr� c sn |� | ��dt|�d �}t�t|��}tt|��D ]4}|||k }t|�dkrZ� |�}ntj}|||< q4|S )Nr r )� searchsortedr- rU r �zerosr �nan)r r� �coarse�indZmusrz r_ Zmu)�reduce_C_functionr r � coarse_bin% s z Axes.hexbin.<locals>.coarse_binrl r� r� r� r� )r\ r� c s< � � | �� � � �| �� � �� | �� � ��| �� � d S r )r� Zget_cmapr Zget_clim)r )�hbar�vbarr r � on_changedq s z Axes.hexbin.<locals>.on_changedZchanged)Lr� r� r� r r� �intrq r r� r@ r� r9 �log10rU r r r Z nonsingular�copy�roundr� �floorr Z logical_notr� r Zhstackr� �isnan�empty�objectr r� rE r r� Z expand_dimsr� r r� �PolyCollectionr� r r� r� rb ra ZLogNormr r Z autoscale�sortr r� r� r� � set_alpharA r r r� rH r r� r� r� r� r � enumerate�diffr� r� r r Z callbacksSMZconnect)Jr- r r� �CZgridsizer ZxscaleZyscale�extentr r r r rf r� r� r ZmincntZ marginalsrD �nxZnyr� r� r� r� Zpaddingry ZsyZxorigZyorigZix1Ziy1Zix2Ziy2Znx1Zny1Znx2Zny2�nZd1Zd2ZbdistZlattice1Zlattice2Zcond1Zcond2ZixZiyZaccumZ good_idxsrz �j�valsr� ZpolygonZpolygonsr �msg�minimumZmaximumr� r r ZxcoarseZvalidr� �values�valZthisminZthismaxr' Zycoarser r )r r r r �hexbin� s� $& $ � @ @" � ""&& &* , , �� � � � z Axes.hexbinc K sJ | � |�}| �|�}| � |�}| �|�}tj||||f|�}| �|� |S )a Add an arrow to the axes. This draws an arrow from ``(x, y)`` to ``(x+dx, y+dy)``. Parameters ---------- x, y : float The x and y coordinates of the arrow base. dx, dy : float The length of the arrow along x and y direction. Returns ------- arrow : `.FancyArrow` The created `.FancyArrow` object. Other Parameters ---------------- **kwargs Optional kwargs (inherited from `.FancyArrow` patch) control the arrow construction and properties: %(FancyArrow)s Notes ----- The resulting arrow is affected by the axes aspect ratio and limits. This may produce an arrow whose head is not square with its stem. To create an arrow whose head is square with its stem, use :meth:`annotate` for example: >>> ax.annotate("", xy=(0.5, 0.5), xytext=(0, 0), ... arrowprops=dict(arrowstyle="->")) )r� r� rn Z FancyArrowr� )r- r r� r r rD r� r r r �arrow{ s ( z Axes.arrowc K s$ t j|||||f|�}| �|� |S r )�mquiver� QuiverKeyr� )r- �Q�X�Y�UrB �kwZqkr r r � quiverkey� s zAxes.quiverkeyc C sX t |�dkrT|dd� \}}| j|||d� | �|�}| �|�}||f|dd � S |S )Nri r rh r� )rU r� r� r� )r- rY r8 r r� r r r � _quiver_units� s zAxes._quiver_unitsc O s8 | � ||�}tj| f|�|�}| j|dd� | �� |S )NTr� )r: r2 �Quiverr� r� )r- rY r8 �qr r r �quiver� s z Axes.quiverc O s8 | � ||�}tj| f|�|�}| j|dd� | �� |S )z %(barbs_doc)s Tr� )r: r2 ZBarbsr� r� )r- rY r8 r r r r �barbs� s z Axes.barbs)rj c O sN t �|tjj�}g }| j|d|i|��D ]}| �|� |�|� q(| �� |S )a� Plot filled polygons. Parameters ---------- *args : sequence of x, y, [color] Each polygon is defined by the lists of *x* and *y* positions of its nodes, optionally followed by a *color* specifier. See :mod:`matplotlib.colors` for supported color specifiers. The standard color cycle is used for polygons without a color specifier. You can plot multiple polygons by providing multiple *x*, *y*, *[color]* groups. For example, each of the following is legal:: ax.fill(x, y) # a polygon with default color ax.fill(x, y, "b") # a blue polygon ax.fill(x, y, x2, y2) # two polygons ax.fill(x, y, "b", x2, y2, "r") # a blue and a red polygon data : indexable object, optional An object with labelled data. If given, provide the label names to plot in *x* and *y*, e.g.:: ax.fill("time", "signal", data={"time": [0, 1, 2], "signal": [0, 1, 0]}) Returns ------- a list of :class:`~matplotlib.patches.Polygon` Other Parameters ---------------- **kwargs : :class:`~matplotlib.patches.Polygon` properties Notes ----- Use :meth:`fill_between` if you would like to fill the region between two curves. rj ) r� r� r� r� r� r= rp r� r� )r- rj rY rD rO Zpolyr r r �fill� s , z Axes.fillru �y2r c s� t d s<t�� tjj�� t� fdd�dD ��s<| j�� � d< | j ��� d� | j �d� t � | � ����t � | � ����t � | � ����d�fd �fd �ffD ]"\}} | jd kr�td | d ��q�|dkr�d}|t�tjttj j���g�� @ }t�t������\���g } t�|�D �]P\} } �| | � } �| | � }�| | � }|dk �rrtjd| }|| ||�\} }}t| ��s��qt| �}t�d| d dft �}|�rȇ��fdd�}|| �}|| �}n | d |d f}| d |d f}||d< |||d < | |d |d �df< ||d |d �d f< | ddd� ||d d�df< |ddd� ||d d�d f< | � |� �qtj | f� �}t� �| �| g�j }t� �| �| g�j }| j!j"|| j#ddd� d| _#| j!j"|| j#ddd� | j$|dd� | �%� |S )a� Fill the area between two horizontal curves. The curves are defined by the points (*x*, *y1*) and (*x*, *y2*). This creates one or multiple polygons describing the filled area. You may exclude some horizontal sections from filling using *where*. By default, the edges connect the given points directly. Use *step* if the filling should be a step function, i.e. constant in between *x*. Parameters ---------- x : array (length N) The x coordinates of the nodes defining the curves. y1 : array (length N) or scalar The y coordinates of the nodes defining the first curve. y2 : array (length N) or scalar, optional, default: 0 The y coordinates of the nodes defining the second curve. where : array of bool (length N), optional, default: None Define *where* to exclude some horizontal regions from being filled. The filled regions are defined by the coordinates ``x[where]``. More precisely, fill between ``x[i]`` and ``x[i+1]`` if ``where[i] and where[i+1]``. Note that this definition implies that an isolated *True* value between two *False* values in *where* will not result in filling. Both sides of the *True* position remain unfilled due to the adjacent *False* values. interpolate : bool, optional This option is only relevant if *where* is used and the two curves are crossing each other. Semantically, *where* is often used for *y1* > *y2* or similar. By default, the nodes of the polygon defining the filled region will only be placed at the positions in the *x* array. Such a polygon cannot describe the above semantics close to the intersection. The x-sections containing the intersection are simply clipped. Setting *interpolate* to *True* will calculate the actual intersection point and extend the filled region up to this point. step : {'pre', 'post', 'mid'}, optional Define *step* if the filling should be a step function, i.e. constant in between *x*. The value determines where the step will occur: - 'pre': The y value is continued constantly to the left from every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the value ``y[i]``. - 'post': The y value is continued constantly to the right from every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the value ``y[i]``. - 'mid': Steps occur half-way between the *x* positions. Other Parameters ---------------- **kwargs All other keyword arguments are passed on to `.PolyCollection`. They control the `.Polygon` properties: %(PolyCollection)s Returns ------- `.PolyCollection` A `.PolyCollection` containing the plotted polygons. See Also -------- fill_betweenx : Fill between two sets of x-values. Notes ----- .. [notes section required to get data note injection right] r] c 3 s | ]}|� kV qd S r r �r� rP r� r r r� g s z$Axes.fill_between.<locals>.<genexpr>�r� rd rd r� )r� r ru r@ r � Input passed into argument "%r"�is not 1-dimensional.NTr rh c s� t | d d�}� || d � }�|| d � �|| d � }�|| d � }t|�dkr�tj�|d �rz� | �| fS tj�|d �r�� | �| fS |�� }t�d|| || �}|�� }t�||| || �}||fS �Nr r rh �r rU r r � is_maskedZargsortZinterp) r �im1Zx_values� diff_valuesZ y1_values� diff_order� diff_root_xZx_order� diff_root_y)r ru r@ r r �get_interp_point� s( � �z+Axes.fill_between.<locals>.get_interp_pointr rl �ZupdatexZupdateyFr� )&r r� r� r� � Collectionr� r� r= r> r� r r� r� r� r r9 r� r� r � logical_or�map�getmaskr@ rA �contiguous_regions�STEP_LOOKUP_MAPrU r r@ r� r! r� �TrJ �update_from_data_xy�ignore_existing_data_limitsr� r� )r- r ru r@ r � interpolater rD r� r� �polys�ind0�ind1ZxsliceZy1sliceZy2slice� step_funcr� r5 rM �start�endr ZXY1ZXY2r )rD r ru r@ r � fill_between s� U �� � � � �zAxes.fill_betweenrs �x2c s� t d s<t�� tjj�� t� fdd�dD ��s<| j�� � d< | j ��� d� | j �d� t � | � ����t � | � ����t � | � ����d�fd �fd �ffD ]"\}} | jd kr�td | d ��q�|dkr�d}|t�tjttj j���g�� @ }t�t������\���g } t�|�D �]P\} } �| | � } �| | � }�| | � }|dk �rrtjd| }|| ||�\} }}t| ��s��qt| �}t�d| d dft �}|�rȇ��fdd�}|| �}|| �}n |d | d f}|d | d f}||d< |||d < ||d |d �df< | |d |d �d f< |ddd� ||d d�df< | ddd� ||d d�d f< | � |� �qtj | f� �}t� �| �| g�j }t� �| �| g�j }| j!j"|| j#ddd� d| _#| j!j"|| j#ddd� | j$|dd� | �%� |S )a� Fill the area between two vertical curves. The curves are defined by the points (*x1*, *y*) and (*x2*, *y*). This creates one or multiple polygons describing the filled area. You may exclude some vertical sections from filling using *where*. By default, the edges connect the given points directly. Use *step* if the filling should be a step function, i.e. constant in between *y*. Parameters ---------- y : array (length N) The y coordinates of the nodes defining the curves. x1 : array (length N) or scalar The x coordinates of the nodes defining the first curve. x2 : array (length N) or scalar, optional, default: 0 The x coordinates of the nodes defining the second curve. where : array of bool (length N), optional, default: None Define *where* to exclude some vertical regions from being filled. The filled regions are defined by the coordinates ``y[where]``. More precisely, fill between ``y[i]`` and ``y[i+1]`` if ``where[i] and where[i+1]``. Note that this definition implies that an isolated *True* value between two *False* values in *where* will not result in filling. Both sides of the *True* position remain unfilled due to the adjacent *False* values. interpolate : bool, optional This option is only relevant if *where* is used and the two curves are crossing each other. Semantically, *where* is often used for *x1* > *x2* or similar. By default, the nodes of the polygon defining the filled region will only be placed at the positions in the *y* array. Such a polygon cannot describe the above semantics close to the intersection. The y-sections containing the intersection are simply clipped. Setting *interpolate* to *True* will calculate the actual intersection point and extend the filled region up to this point. step : {'pre', 'post', 'mid'}, optional Define *step* if the filling should be a step function, i.e. constant in between *y*. The value determines where the step will occur: - 'pre': The y value is continued constantly to the left from every *x* position, i.e. the interval ``(x[i-1], x[i]]`` has the value ``y[i]``. - 'post': The y value is continued constantly to the right from every *x* position, i.e. the interval ``[x[i], x[i+1])`` has the value ``y[i]``. - 'mid': Steps occur half-way between the *x* positions. Other Parameters ---------------- **kwargs All other keyword arguments are passed on to `.PolyCollection`. They control the `.Polygon` properties: %(PolyCollection)s Returns ------- `.PolyCollection` A `.PolyCollection` containing the plotted polygons. See Also -------- fill_between : Fill between two sets of y-values. Notes ----- .. [notes section required to get data note injection right] r] c 3 s | ]}|� kV qd S r r rA r� r r r� s z%Axes.fill_betweenx.<locals>.<genexpr>rB rd )r� r� rD )r� r� rs r` r rC rD NTr rh c s� t | d d�}�|| d � }� || d � �|| d � }� || d � }t|�dkr�tj�|d �rz� | �| fS tj�|d �r�� | �| fS |�� }t�d|| || �}|�� }t�||| || �}||fS rE rF ) r rH Zy_valuesrI Z x1_valuesrJ rL Zy_orderrK )rs r` r� r r rM E s( � �z,Axes.fill_betweenx.<locals>.get_interp_pointr rl rN Fr� )&r r� r� r� rO r� r� r= r> r� r r� r� r� r r9 r� r� r rP rQ rR r@ rA rS rT rU r r@ r� r! r� rU rJ rV rW r� r� )r- r� rs r` r r rX rD r� r� rY rZ r[ ZysliceZx1sliceZx2slicer\ r� r6 rM r] r^ r ZX1YZX2Yr )rD rs r` r� r � fill_betweenx� s� U �� � � � �zAxes.fill_betweenxr� �imlim� @c K s� |dk r t |tj�s td��|dkr,td }| �|� tj| |||| | f| | |d�|��}|�|� |� |� |� � dkr�|� | j � |dk s�|dk r�|� ||� n|�� |�|� |�|�� � | �|� |S )a! Display an image, i.e. data on a 2D regular raster. Parameters ---------- X : array-like or PIL image The image data. Supported array shapes are: - (M, N): an image with scalar data. The data is visualized using a colormap. - (M, N, 3): an image with RGB values (0-1 float or 0-255 int). - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int), i.e. including transparency. The first two dimensions (M, N) define the rows and columns of the image. Out-of-range RGB(A) values are clipped. cmap : str or `~matplotlib.colors.Colormap`, optional The Colormap instance or registered colormap name used to map scalar data to colors. This parameter is ignored for RGB(A) data. Defaults to :rc:`image.cmap`. norm : `~matplotlib.colors.Normalize`, optional The `Normalize` instance used to scale scalar data to the [0, 1] range before mapping to colors using *cmap*. By default, a linear scaling mapping the lowest value to 0 and the highest to 1 is used. This parameter is ignored for RGB(A) data. aspect : {'equal', 'auto'} or float, optional Controls the aspect ratio of the axes. The aspect is of particular relevance for images since it may distort the image, i.e. pixel will not be square. This parameter is a shortcut for explicitly calling `.Axes.set_aspect`. See there for further details. - 'equal': Ensures an aspect ratio of 1. Pixels will be square (unless pixel sizes are explicitly made non-square in data coordinates using *extent*). - 'auto': The axes is kept fixed and the aspect is adjusted so that the data fit in the axes. In general, this will result in non-square pixels. If not given, use :rc:`image.aspect` (default: 'equal'). interpolation : str, optional The interpolation method used. If *None* :rc:`image.interpolation` is used, which defaults to 'nearest'. Supported values are 'none', 'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos'. If *interpolation* is 'none', then no interpolation is performed on the Agg, ps, pdf and svg backends. Other backends will fall back to 'nearest'. Note that most SVG renders perform interpolation at rendering and that the default interpolation method they implement may differ. See :doc:`/gallery/images_contours_and_fields/interpolation_methods` for an overview of the supported interpolation methods. Some interpolation methods require an additional radius parameter, which can be set by *filterrad*. Additionally, the antigrain image resize filter is controlled by the parameter *filternorm*. alpha : scalar, optional The alpha blending value, between 0 (transparent) and 1 (opaque). This parameter is ignored for RGBA input data. vmin, vmax : scalar, optional When using scalar data and no explicit *norm*, *vmin* and *vmax* define the data range that the colormap covers. By default, the colormap covers the complete value range of the supplied data. *vmin*, *vmax* are ignored if the *norm* parameter is used. origin : {'upper', 'lower'}, optional Place the [0,0] index of the array in the upper left or lower left corner of the axes. The convention 'upper' is typically used for matrices and images. If not given, :rc:`image.origin` is used, defaulting to 'upper'. Note that the vertical axes points upward for 'lower' but downward for 'upper'. See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for examples and a more detailed description. extent : scalars (left, right, bottom, top), optional The bounding box in data coordinates that the image will fill. The image is stretched individually along x and y to fill the box. The default extent is determined by the following conditions. Pixels have unit size in data coordinates. Their centers are on integer coordinates, and their center coordinates range from 0 to columns-1 horizontally and from 0 to rows-1 vertically. Note that the direction of the vertical axis and thus the default values for top and bottom depend on *origin*: - For ``origin == 'upper'`` the default is ``(-0.5, numcols-0.5, numrows-0.5, -0.5)``. - For ``origin == 'lower'`` the default is ``(-0.5, numcols-0.5, -0.5, numrows-0.5)``. See the :doc:`/tutorials/intermediate/imshow_extent` tutorial for examples and a more detailed description. filternorm : bool, optional, default: True A parameter for the antigrain image resize filter (see the antigrain documentation). If *filternorm* is set, the filter normalizes integer values and corrects the rounding errors. It doesn't do anything with the source floating point values, it corrects only integers according to the rule of 1.0 which means that any sum of pixel weights must be equal to 1.0. So, the filter function must produce a graph of the proper shape. filterrad : float > 0, optional, default: 4.0 The filter radius for filters that have a radius parameter, i.e. when interpolation is one of: 'sinc', 'lanczos' or 'blackman'. resample : bool, optional When *True*, use a full resampling method. When *False*, only resample when the output image is larger than the input image. url : str, optional Set the url of the created `.AxesImage`. See `.Artist.set_url`. Returns ------- image : `~matplotlib.image.AxesImage` Other Parameters ---------------- **kwargs : `~matplotlib.artist.Artist` properties These parameters are passed on to the constructor of the `.AxesImage` artist. See also -------- matshow : Plot a matrix or an array as an image. Notes ----- Unless *extent* is used, pixel centers will be located at integer coordinates. In other words: the origin will coincide with the center of pixel (0, 0). There are two common representations for RGB images with an alpha channel: - Straight (unassociated) alpha: R, G, and B channels represent the color of the pixel, disregarding its opacity. - Premultiplied (associated) alpha: R, G, and B channels represent the color of the pixel, adjusted for its opacity by multiplication. `~matplotlib.pyplot.imshow` expects RGB images adopting the straight (unassociated) alpha representation. Nr� z image.aspect)� filternorm� filterrad�resample)r r� r� r9 r rn �mimage� AxesImage�set_datar# � get_clip_pathr� r� r r Zset_url� set_extentZ get_extent� add_image)r- r5 r r �aspect� interpolationrf r r �originr' r� rd re rb rf ZurlrD �imr r r �imshow{ s4 +� �� z Axes.imshow)�allmatchc G s` t |�dkr~t�|d �}|j\}}|rFt�t�|�t�|��\}}n$t�t�|d �t�|d ��\}}t�|�}|||fS t |�dk�rt�|d �}dd� |d d� D �\}}| dk�r tj� |�s�tj� |�r�t d��t |tjj j �r�|j}t |tjj j ��r |j}|j\}}ntd | | f ��|jd }|jd } |jdk�sX|jd dk�rr|�d|�} | j| dd �}|jdk�s�|jd dk�r�|�| d�} | j|dd �}|j|jk�r�td | | f ��|�r�|| f||fk�rLtd |j|| | f ��nV|||d fk�r|| | d fk�s0td |j|| | f ��|d | d �d |d �f }t�|�}|||fS )Nr r ri rh c S s g | ]}t �|��qS r )r� �safe_masked_invalid)r� r� r r r r� Y s z$Axes._pcolorargs.<locals>.<listcomp>� pcolormeshzxx and y arguments to pcolormesh cannot have non-finite values or be of type numpy.ma.core.MaskedArray with masked valuesz%Illegal arguments to %s; see help(%s)rl �r� z,Incompatible X, Y inputs to %s; see help(%s)zKDimensions of C %s are incompatible with X (%d) and/or Y (%d); see help(%s))rU r r� r� Zmeshgridr r� rs r rG r9 r ZcoreZ MaskedArrayrj rV r �reshaperE ) �funcnamerr rY r& ZnumRowsZnumColsr5 r6 r �Nyr r� r r r � _pcolorargsA sz � � � �� ��$ �� zAxes._pcolorargs)rf r r r r c ) O sD | j d|�ddi�\}} } |j\} } | j|| |d� | �|�}| �| �} t�| �} t�|�}t�| �} t�|�t�| � } | dd�dd�f | dd�dd�f | dd�dd�f | dd�dd�f }t�| �| } | }t�|dd�dd�f �| }t�| dd�dd�f �| }t�|dd�dd�f �| }t�| dd�dd�f �| }t�|dd�dd�f �| }t�| dd�dd�f �| }t�|dd�dd�f �| }t�| dd�dd�f �| }t |�}t j ||||||||||g dd �}|� |d d f�}t�| d| d �d| d �f �| } d }d |k�rJ|� d �|d< |�d|� d|k�rn|� d�|d< |�dd�} d|k�r�|� d�|d< d|k�r�t�| d��r�d|d< |�dd� tj|f|�} | �|� | �| � |dk �r t|tj��s td��| �|� | �|� | �||� | � � | � d� |� � } | � � } | j } t| t j!��snt"| d��rn| �#| j$�} | �r�t%| �&| j'���r�| | j' }!t �(| | g�j)�*t+�}"|!�,|"�}#|#d } |#d } | j-| dd� t �.| �}$t �/| �}%t �.| �}&t �/| �}'|$|%g| j0j1dd�< |&|'g| j0j2dd�< |$|&f|%|'ff}(| �3|(� | �4� | S )ab Create a pseudocolor plot with a non-regular rectangular grid. Call signature:: pcolor([X, Y,] C, **kwargs) *X* and *Y* can be used to specify the corners of the quadrilaterals. .. hint:: ``pcolor()`` can be very slow for large arrays. In most cases you should use the similar but much faster `~.Axes.pcolormesh` instead. See there for a discussion of the differences. Parameters ---------- C : array_like A scalar 2-D array. The values will be color-mapped. X, Y : array_like, optional The coordinates of the quadrilateral corners. The quadrilateral for ``C[i,j]`` has corners at:: (X[i+1, j], Y[i+1, j]) (X[i+1, j+1], Y[i+1, j+1]) +--------+ | C[i,j] | +--------+ (X[i, j], Y[i, j]) (X[i, j+1], Y[i, j+1]), Note that the column index corresponds to the x-coordinate, and the row index corresponds to y. For details, see the :ref:`Notes <axes-pcolor-grid-orientation>` section below. The dimensions of *X* and *Y* should be one greater than those of *C*. Alternatively, *X*, *Y* and *C* may have equal dimensions, in which case the last row and column of *C* will be ignored. If *X* and/or *Y* are 1-D arrays or column vectors they will be expanded as needed into the appropriate 2-D arrays, making a rectangular grid. cmap : str or `~matplotlib.colors.Colormap`, optional A Colormap instance or registered colormap name. The colormap maps the *C* values to colors. Defaults to :rc:`image.cmap`. norm : `~matplotlib.colors.Normalize`, optional The Normalize instance scales the data values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling. vmin, vmax : scalar, optional, default: None The colorbar range. If *None*, suitable min/max values are automatically chosen by the `~.Normalize` instance (defaults to the respective min/max values of *C* in case of the default linear scaling). edgecolors : {'none', None, 'face', color, color sequence}, optional The color of the edges. Defaults to 'none'. Possible values: - 'none' or '': No edge. - *None*: :rc:`patch.edgecolor` will be used. Note that currently :rc:`patch.force_edgecolor` has to be True for this to work. - 'face': Use the adjacent face color. - An mpl color or sequence of colors will set the edge color. The singular form *edgecolor* works as an alias. alpha : scalar, optional, default: None The alpha blending value of the face color, between 0 (transparent) and 1 (opaque). Note: The edgecolor is currently not affected by this. snap : bool, optional, default: False Whether to snap the mesh to pixel boundaries. Returns ------- collection : `matplotlib.collections.Collection` Other Parameters ---------------- antialiaseds : bool, optional, default: False The default *antialiaseds* is False if the default *edgecolors*\ ="none" is used. This eliminates artificial lines at patch boundaries, and works regardless of the value of alpha. If *edgecolors* is not "none", then the default *antialiaseds* is taken from :rc:`patch.antialiased`, which defaults to True. Stroking the edges may be preferred if *alpha* is 1, but will cause artifacts otherwise. **kwargs Additionally, the following arguments are allowed. They are passed along to the `~matplotlib.collections.PolyCollection` constructor: %(PolyCollection)s See Also -------- pcolormesh : for an explanation of the differences between pcolor and pcolormesh. imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a faster alternative. Notes ----- **Masked arrays** *X*, *Y* and *C* may be masked arrays. If either ``C[i, j]``, or one of the vertices surrounding ``C[i,j]`` (*X* or *Y* at ``[i, j], [i+1, j], [i, j+1], [i+1, j+1]``) is masked, nothing is plotted. .. _axes-pcolor-grid-orientation: **Grid orientation** The grid orientation follows the standard matrix convention: An array *C* with shape (nrows, ncolumns) is plotted with the column number as *X* and the row number as *Y*. **Handling of pcolor() end-cases** ``pcolor()`` displays all columns of *C* if *X* and *Y* are not specified, or if *X* and *Y* have one more column than *C*. If *X* and *Y* have the same number of columns as *C* then the last column of *C* is dropped. Similarly for the rows. Note: This behavior is different from MATLAB's ``pcolor()``, which always discards the last row and column of *C*. �pcolorrr Fr� r rl r Nru r[ rh )r� r� r� re r� rb � antialiasedZ antialiasedsZsnapr� �_as_mpl_transform).r ).r r� )rz )5ry r� r� r� r� r r� Z getmaskarray�filledrU r �stackrv r_ r r� Z_str_lower_equalr� r! r# r� r r� r� r9 r� r� r r r� Z compressed� _transformr � Transformr� r| �axesr� �contains_branch_seperatelyrm ZvstackrU r� r@ r\ r� r r rH r r� r� r� ))r- rf r r r r rY rD r5 r6 r& rx r r� ZxymaskZunmaskZX1ZY1ZX2ZY2ZX3ZY3ZX4ZY4Znpolyrv r� r� Zecr r r� r� � trans_to_dataZptsZtransformed_ptsr� r� r� r� r� r r r rz � s� &�� "& � � z Axes.pcolorZflat)rf r r r r �shadingr{ c O s� |� � }| �dd� |dk} | jd|�d| i�\} } } | j\}}| �� } | �� } | j| | | d� | �| �} | �| �} | �� } t� | | f�j t dd�}t j |d |d |f||d �| ��}|�|� |�| � |d k r�t|tj�s�td ��|�|� |�|� |�||� |�� | �d� |j}t|tj��sFt |d ��rF|� | j �}|�rrt |� | j!���rr|| j! }|�"|�}| j#|dd� tj$|dd�\}}tj%|dd�\}}||g|j&j'd d �< ||g|j&j(d d �< ||f||ff}| �)|� | �*� |S )a� Create a pseudocolor plot with a non-regular rectangular grid. Call signature:: pcolor([X, Y,] C, **kwargs) *X* and *Y* can be used to specify the corners of the quadrilaterals. .. note:: ``pcolormesh()`` is similar to :func:`~Axes.pcolor`. It's much faster and preferred in most cases. For a detailed discussion on the differences see :ref:`Differences between pcolor() and pcolormesh() <differences-pcolor-pcolormesh>`. Parameters ---------- C : array_like A scalar 2-D array. The values will be color-mapped. X, Y : array_like, optional The coordinates of the quadrilateral corners. The quadrilateral for ``C[i,j]`` has corners at:: (X[i+1, j], Y[i+1, j]) (X[i+1, j+1], Y[i+1, j+1]) +--------+ | C[i,j] | +--------+ (X[i, j], Y[i, j]) (X[i, j+1], Y[i, j+1]), Note that the column index corresponds to the x-coordinate, and the row index corresponds to y. For details, see the :ref:`Notes <axes-pcolormesh-grid-orientation>` section below. The dimensions of *X* and *Y* should be one greater than those of *C*. Alternatively, *X*, *Y* and *C* may have equal dimensions, in which case the last row and column of *C* will be ignored. If *X* and/or *Y* are 1-D arrays or column vectors they will be expanded as needed into the appropriate 2-D arrays, making a rectangular grid. cmap : str or `~matplotlib.colors.Colormap`, optional A Colormap instance or registered colormap name. The colormap maps the *C* values to colors. Defaults to :rc:`image.cmap`. norm : `~matplotlib.colors.Normalize`, optional The Normalize instance scales the data values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling. vmin, vmax : scalar, optional, default: None The colorbar range. If *None*, suitable min/max values are automatically chosen by the `~.Normalize` instance (defaults to the respective min/max values of *C* in case of the default linear scaling). edgecolors : {'none', None, 'face', color, color sequence}, optional The color of the edges. Defaults to 'none'. Possible values: - 'none' or '': No edge. - *None*: :rc:`patch.edgecolor` will be used. Note that currently :rc:`patch.force_edgecolor` has to be True for this to work. - 'face': Use the adjacent face color. - An mpl color or sequence of colors will set the edge color. The singular form *edgecolor* works as an alias. alpha : scalar, optional, default: None The alpha blending value, between 0 (transparent) and 1 (opaque). shading : {'flat', 'gouraud'}, optional The fill style, Possible values: - 'flat': A solid color is used for each quad. The color of the quad (i, j), (i+1, j), (i, j+1), (i+1, j+1) is given by ``C[i,j]``. - 'gouraud': Each quad will be Gouraud shaded: The color of the corners (i', j') are given by ``C[i',j']``. The color values of the area in between is interpolated from the corner values. When Gouraud shading is used, *edgecolors* is ignored. snap : bool, optional, default: False Whether to snap the mesh to pixel boundaries. Returns ------- mesh : `matplotlib.collections.QuadMesh` Other Parameters ---------------- **kwargs Additionally, the following arguments are allowed. They are passed along to the `~matplotlib.collections.QuadMesh` constructor: %(QuadMesh)s See Also -------- pcolor : An alternative implementation with slightly different features. For a detailed discussion on the differences see :ref:`Differences between pcolor() and pcolormesh() <differences-pcolor-pcolormesh>`. imshow : If *X* and *Y* are each equidistant, `~.Axes.imshow` can be a faster alternative. Notes ----- **Masked arrays** *C* may be a masked array. If ``C[i, j]`` is masked, the corresponding quadrilateral will be transparent. Masking of *X* and *Y* is not supported. Use `~.Axes.pcolor` if you need this functionality. .. _axes-pcolormesh-grid-orientation: **Grid orientation** The grid orientation follows the standard matrix convention: An array *C* with shape (nrows, ncolumns) is plotted with the column number as *X* and the row number as *Y*. .. _differences-pcolor-pcolormesh: **Differences between pcolor() and pcolormesh()** Both methods are used to create a pseudocolor plot of a 2-D array using quadrilaterals. The main difference lies in the created object and internal data handling: While `~.Axes.pcolor` returns a `.PolyCollection`, `~.Axes.pcolormesh` returns a `.QuadMesh`. The latter is more specialized for the given purpose and thus is faster. It should almost always be preferred. There is also a slight difference in the handling of masked arrays. Both `~.Axes.pcolor` and `~.Axes.pcolormesh` support masked arrays for *C*. However, only `~.Axes.pcolor` supports masked arrays for *X* and *Y*. The reason lies in the internal handling of the masked values. `~.Axes.pcolor` leaves out the respective polygons from the PolyCollection. `~.Axes.pcolormesh` sets the facecolor of the masked elements to transparent. You can see the difference when using edgecolors. While all edges are drawn irrespective of masking in a QuadMesh, the edge between two adjacent masked quadrilaterals in `~.Axes.pcolor` is not drawn as the corresponding polygons do not exist in the PolyCollection. Another difference is the support of Gouraud shading in `~.Axes.pcolormesh`, which is not available with `~.Axes.pcolor`. r� r Zgouraudrt rr r� F)r r )r{ r� Nr� r| r� r ru )rt )+r7 r ry r� r� r� r� r� r r� r� r@ r� �QuadMeshr# r� r r� r� r9 r� r� r r r� r r r� r� r| r� r� r� rm r\ r� r r rH r r� r� r� )r- rf r r r r r� r{ rY rD rr r5 r6 r& rx r �coordsr r� r� r� r� r� r� r� r r r rt p s^ ! �� � � zAxes.pcolormeshc O s� |dk r t |tj�s td��|d }t�|�dd� \} } t|�dkr^d} d| g} d| g} �nt|�dk�rZ|dd� \} } t�| �} t�| �} | jdk�r | jdk�r | j dkr�| j dkr�d} nZt� | �}t� | �}t� |�d t� |� � � k �rt� |�d t� |� � � k �rd} nd } n:| jdk�rP| jdk�rP|jdk�rJtd ��d } ntd ��ntd��| d k�r@t�|�}| �� }| �� }| d }| d }t�|| dftj�}||dd�df< ||dd�df< tj| | |ddd�}|�|� |�|� |�|� |�|� | j|dd� |�� |�� |�� |�� f\}}}}|}n�| d | d | d | d f\}}}}| dk�r�t j | ||fdd||||fd�|��}|� |� |�|� n<| d k�r�t j | | | |f|||d�|��}|� ||||f� | �!|� |}|dk �s|dk �r|�"||� n|�#� |�$� dk�r8|�%| j&� ||g|j'j(dd�< ||g|j'j)dd�< | �*t�+||g||gg�� | j,dd� |S )aw Create a pseudocolor plot with a non-regular rectangular grid. Call signature:: ax.pcolorfast([X, Y], C, /, **kwargs) This method is similar to ~.Axes.pcolor` and `~.Axes.pcolormesh`. It's designed to provide the fastest pcolor-type plotting with the Agg backend. To achieve this, it uses different algorithms internally depending on the complexity of the input grid (regular rectangular, non-regular rectangular or arbitrary quadrilateral). .. warning:: This method is experimental. Compared to `~.Axes.pcolor` or `~.Axes.pcolormesh` it has some limitations: - It supports only flat shading (no outlines) - It lacks support for log scaling of the axes. - It does not have a have a pyplot wrapper. Parameters ---------- C : array-like(M, N) A 2D array or masked array. The values will be color-mapped. This argument can only be passed positionally. C can in some cases be 3D with the last dimension as rgb(a). This is available when C qualifies for image or pcolorimage type, will throw a TypeError if C is 3D and quadmesh. X, Y : tuple or array-like, default: ``(0, N)``, ``(0, M)`` *X* and *Y* are used to specify the coordinates of the quadrilaterals. There are different ways to do this: - Use tuples ``X=(xmin, xmax)`` and ``Y=(ymin, ymax)`` to define a *uniform rectangular grid*. The tuples define the outer edges of the grid. All individual quadrilaterals will be of the same size. This is the fastest version. - Use 1D arrays *X*, *Y* to specify a *non-uniform rectangular grid*. In this case *X* and *Y* have to be monotonic 1D arrays of length *N+1* and *M+1*, specifying the x and y boundaries of the cells. The speed is intermediate. Note: The grid is checked, and if found to be uniform the fast version is used. - Use 2D arrays *X*, *Y* if you need an *arbitrary quadrilateral grid* (i.e. if the quadrilaterals are not rectangular). In this case *X* and *Y* are 2D arrays with shape (M, N), specifying the x and y coordinates of the corners of the colored quadrilaterals. See `~.Axes.pcolormesh` for details. This is the most general, but the slowest to render. It may produce faster and more compact output using ps, pdf, and svg backends, however. These arguments can only be passed positionally. cmap : str or `~matplotlib.colors.Colormap`, optional A Colormap instance or registered colormap name. The colormap maps the *C* values to colors. Defaults to :rc:`image.cmap`. norm : `~matplotlib.colors.Normalize`, optional The Normalize instance scales the data values to the canonical colormap range [0, 1] for mapping to colors. By default, the data range is mapped to the colorbar range using linear scaling. vmin, vmax : scalar, optional, default: None The colorbar range. If *None*, suitable min/max values are automatically chosen by the `~.Normalize` instance (defaults to the respective min/max values of *C* in case of the default linear scaling). alpha : scalar, optional, default: None The alpha blending value, between 0 (transparent) and 1 (opaque). snap : bool, optional, default: False Whether to snap the mesh to pixel boundaries. Returns ------- image : `.AxesImage` or `.PcolorImage` or `.QuadMesh` The return type depends on the type of grid: - `.AxesImage` for a regular rectangular grid. - `.PcolorImage` for a non-regular rectangular grid. - `.QuadMesh` for a non-rectangular grid. Notes ----- .. [notes section required to get data note injection right] Nr� rl rh r �imager ri r) Z pcolorimagezUpcolorfast needs to use quadmesh, which is not supported when x and y are 2D and C 3DZquadmeshz'arguments do not match valid signaturesz need 1 argument or 3 argumentsr )r� Fr� �nearestr7 )rn ro r' )r r rf Tr )-r r� r� r9 r r� rU r� r r r% r� �absr� rV r r� r r� r� r� r# r� r� r� r� r r rg rh ri Z PcolorImagerk rl r r rj r� r� rH r r� r� r� r� ) r- rf r r r r rY rD r& �nrr� Zstyler r� r r r5 r6 r rx r� r Zxlry Zybr{ r� rp r r r � pcolorfastE s� h� � � $$ �� �� zAxes.pcolorfastc O s& d|d< t j| f|�|�}| �� |S )NFr} ��mcontour�QuadContourSetr� �r- rY rD Zcontoursr r r �contour s z Axes.contourc O s& d|d< t j| f|�|�}| �� |S )NTr} r� r� r r r �contourf s z Axes.contourfc O s |j ||�S r )�clabel)r- ZCSrY rD r r r r� # s z Axes.clabelr rS r r� c ; s� |}ddl m} t�|�r |g}� dkr0td � |dkrDtd| ��| dkrXtd| ��| d krltd | ��|d kr||s|d }|dk r�|dk r�td ��|dk r�tjdddddd� t�|�dk}t� |d�}t |�}�j |d |d� �fdd�|D �}|dk �r �� |�}|dk �r"t� |d�}n dg| }t |�|k�rBtd��t ||�D ].\}}|dk �rLt |�t |�k�rLtd���qL| dk�r��fdd�||�D �} n0t�| �} t | �|k�r�d|t | �f }t|��t� }|dk�rHtj}tj }|D ]0}t |��r�t|t�|��}t|t�|��}�q�t�||g��� �sH||k�sH||f}|�s�t |�d k�r�|dk �rrt�|�} nd} tt�|�� || �� n||d < t|��p�t|�}|�r�|�s�||d < g } d} ||�D ]x} tj|| � fd|| i|��\} � | � t �} | dk�r t� t � �d | j �} |�r6| | 7 } | | dd�< | � | � �q�|�r�|�r�t�!� �}!| D ]"} | |! | d �"� | dd�< �q^|�r�t#d��t$|t%��r�|dk �r�t#ddd ��|�r· �fd d�| D �} n�fd!d�| D �} g }"��&� }#��'� }$��(d"� ��)d"� |�*d#��r�t�!� �}%| dk �r8t�+| dd �}&n(t | �d k�r\|�rVtd$ �r\d%}&nd&}&|d#k�r�|�s�|&|% | }'|'}(d'|& |% d d | })n |d k�s�|�r�|&|% }'d(\})}(| d)k�r�|)d*|% 7 })n| d+k�r�|)|%7 })| d,k�r��j,}*d-}+n �j-}*d.}+t | | �D ]�\} },|dk�r.t� t | ��}|�r>| | }-n| }-|*� dd � |) |-|'fd/| |,d0�|+|i��}.|"� |.� |�r�| |dd�< |)|(7 })�q�n�|�*d1�� r�t� d2t � � d3 �}t� d2t � � d3 �}/� � dd � |dd4t � � d d4�< |d d4t � � d d4�< |d d4t � � d � ddd � |d4t � � d d�< |dk�rbt� t � �d �}|| |/d d4t � � d d4�< |/d4d4t � � d4�< |/d d4t � � d � ddd � |/d4t � � d d�< | �rv| d,k�r�j.d5d6d7� �j/j0j1}0n�j2d5d6d8� �j3j0j1}0t�|�dk�r(t�|�}1n:|�s8|dk �rZt�4| �}2t�|2|2dk �|0 }1nd&|0 }1|1|1 |/d< |/d < nd}1| d-k�r�|d*� d � d 8 }n"| d+k�r�|d*� d � d 7 }|d9k}3g g }4}5| D ]�} |�r"|/d |/d< |/d d4t � � d � ddd � |/d4t � � d d�< | | | | |/d d4t � � d d4�< |/d4d4t � � d4�< | �rn|1|/|/|1k < | d,k�r�|4� |/�5� � |5� |�5� � n |4� |�5� � |5� |/�5� � �q�|3�r�d n d4t � � }6t6t7t |4|5| ���D ]V\}}/},|"� �j8|d|6� |/d|6� |3� rd nd|,|3� r dn|,|3� r*|3ndd:�� �q�|"D ]D}7|7D ]8}.| d;k� rb|.j9j:� |1� n| d,k� rD|.j9j;� |1� � qD� q<|"�<� ��(|#� ��)|$� ��=� |dk� r�dg}8n:t$|t>�� r�|g}8n&t�?|�� s�t>|�g}8nd<d� |D �}8t@�A|"|8�D ]^\}.}9|.� r�|.d }:|:�B|� |9dk � r2|:�C|9� |.d d� D ]}:|:�B|� |:�Cd=� � q>� q�|d k� r�| d � t�Dd>|"d �fS | � t�Dd?|"�fS dS )@a�" Plot a histogram. Compute and draw the histogram of *x*. The return value is a tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*, *patches1*,...]) if the input contains multiple data. See the documentation of the *weights* parameter to draw a histogram of already-binned data. Multiple data can be provided via *x* as a list of datasets of potentially different length ([*x0*, *x1*, ...]), or as a 2-D ndarray in which each column is a dataset. Note that the ndarray form is transposed relative to the list form. Masked arrays are not supported at present. Parameters ---------- x : (n,) array or sequence of (n,) arrays Input values, this takes either a single array or a sequence of arrays which are not required to be of the same length. bins : int or sequence or str, optional If an integer is given, ``bins + 1`` bin edges are calculated and returned, consistent with `numpy.histogram`. If `bins` is a sequence, gives bin edges, including left edge of first bin and right edge of last bin. In this case, `bins` is returned unmodified. All but the last (righthand-most) bin is half-open. In other words, if `bins` is:: [1, 2, 3, 4] then the first bin is ``[1, 2)`` (including 1, but excluding 2) and the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which *includes* 4. Unequally spaced bins are supported if *bins* is a sequence. With Numpy 1.11 or newer, you can alternatively provide a string describing a binning strategy, such as 'auto', 'sturges', 'fd', 'doane', 'scott', 'rice' or 'sqrt', see `numpy.histogram`. The default is taken from :rc:`hist.bins`. range : tuple or None, optional The lower and upper range of the bins. Lower and upper outliers are ignored. If not provided, *range* is ``(x.min(), x.max())``. Range has no effect if *bins* is a sequence. If *bins* is a sequence or *range* is specified, autoscaling is based on the specified bin range instead of the range of x. Default is ``None`` density : bool, optional If ``True``, the first element of the return tuple will be the counts normalized to form a probability density, i.e., the area (or integral) under the histogram will sum to 1. This is achieved by dividing the count by the number of observations times the bin width and not dividing by the total number of observations. If *stacked* is also ``True``, the sum of the histograms is normalized to 1. Default is ``None`` for both *normed* and *density*. If either is set, then that value will be used. If neither are set, then the args will be treated as ``False``. If both *density* and *normed* are set an error is raised. weights : (n, ) array_like or None, optional An array of weights, of the same shape as *x*. Each value in *x* only contributes its associated weight towards the bin count (instead of 1). If *normed* or *density* is ``True``, the weights are normalized, so that the integral of the density over the range remains 1. Default is ``None``. This parameter can be used to draw a histogram of data that has already been binned, e.g. using `np.histogram` (by treating each bin as a single point with a weight equal to its count) :: counts, bins = np.histogram(data) plt.hist(bins[:-1], bins, weights=counts) (or you may alternatively use `~.bar()`). cumulative : bool, optional If ``True``, then a histogram is computed where each bin gives the counts in that bin plus all bins for smaller values. The last bin gives the total number of datapoints. If *normed* or *density* is also ``True`` then the histogram is normalized such that the last bin equals 1. If *cumulative* evaluates to less than 0 (e.g., -1), the direction of accumulation is reversed. In this case, if *normed* and/or *density* is also ``True``, then the histogram is normalized such that the first bin equals 1. Default is ``False`` bottom : array_like, scalar, or None Location of the bottom baseline of each bin. If a scalar, the base line for each bin is shifted by the same amount. If an array, each bin is shifted independently and the length of bottom must match the number of bins. If None, defaults to 0. Default is ``None`` histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, optional The type of histogram to draw. - 'bar' is a traditional bar-type histogram. If multiple data are given the bars are arranged side by side. - 'barstacked' is a bar-type histogram where multiple data are stacked on top of each other. - 'step' generates a lineplot that is by default unfilled. - 'stepfilled' generates a lineplot that is by default filled. Default is 'bar' align : {'left', 'mid', 'right'}, optional Controls how the histogram is plotted. - 'left': bars are centered on the left bin edges. - 'mid': bars are centered between the bin edges. - 'right': bars are centered on the right bin edges. Default is 'mid' orientation : {'horizontal', 'vertical'}, optional If 'horizontal', `~matplotlib.pyplot.barh` will be used for bar-type histograms and the *bottom* kwarg will be the left edges. rwidth : scalar or None, optional The relative width of the bars as a fraction of the bin width. If ``None``, automatically compute the width. Ignored if *histtype* is 'step' or 'stepfilled'. Default is ``None`` log : bool, optional If ``True``, the histogram axis will be set to a log scale. If *log* is ``True`` and *x* is a 1D array, empty bins will be filtered out and only the non-empty ``(n, bins, patches)`` will be returned. Default is ``False`` color : color or array_like of colors or None, optional Color spec or sequence of color specs, one per dataset. Default (``None``) uses the standard line color sequence. Default is ``None`` label : str or None, optional String, or sequence of strings to match multiple datasets. Bar charts yield multiple patches per dataset, but only the first gets the label, so that the legend command will work as expected. default is ``None`` stacked : bool, optional If ``True``, multiple data are stacked on top of each other If ``False`` multiple data are arranged side by side if histtype is 'bar' or on top of each other if histtype is 'step' Default is ``False`` normed : bool, optional Deprecated; use the density keyword argument instead. Returns ------- n : array or list of arrays The values of the histogram bins. See *density* and *weights* for a description of the possible semantics. If input *x* is an array, then this is an array of length *nbins*. If input is a sequence of arrays ``[data1, data2,..]``, then this is a list of arrays with the values of the histograms for each of the arrays in the same order. The dtype of the array *n* (or of its element arrays) will always be float even if no weighting or normalization is used. bins : array The edges of the bins. Length nbins + 1 (nbins left edges and right edge of last bin). Always a single array even when multiple data sets are passed in. patches : list or list of lists Silent list of individual patches used to create the histogram or list of such list if multiple input datasets. Other Parameters ---------------- **kwargs : `~matplotlib.patches.Patch` properties See also -------- hist2d : 2D histograms r )r Nz hist.bins)rS � barstackedr � stepfilledz histtype %s is not recognized)r1 r r2 z align kwarg %s is not recognized)r� r� z&orientation kwarg %s is not recognizedr� Tztkwargs 'density' and 'normed' cannot be used simultaneously. Please only use 'density', since 'normed'is deprecated.z2.1z'normed'r� z 'density'r+ )r� r� r� Zremovalr r� c s g | ]}� � |��qS r )r� )r� r^ r, r r r� . s z Axes.hist.<locals>.<listcomp>r z'weights should have the same shape as xc s g | ]}� j �� �qS r )r� r> )r� rz r, r r r� B s zVcolor kwarg must have one color per data set. %d data sets and %d colors were providedr r �densityrl c s& g | ] }|t �� � � �� � �qS r )r r% r� �r� �m)r �slcr r r� � s c s g | ]}|� � � � �qS r )r� r� )r� r r r� � s FrS r] r$ r r )r r r rc r2 r� r1 r~ r/ )r% r� r� r r� ri rh r� r- r/ r. r� )�closedrd re r? r� c S s g | ] }t |��qS r )r )r� Zlabr r r r� 0 s r0 r< zLists of Patches)E�builtinsr r r� r r9 r� ro r Z _reshape_2DrU r� r� r� r� r� rs �infr Znanminr Znanmaxr r� Z concatenater r� r r� r@ r rF r� r% rp �slicer r Zget_autoscalex_onZget_autoscaley_onZset_autoscalex_onZset_autoscaley_onr� r- rT rS r� rG Z_scale�baser rN r� r �reversedr� r? rH r� r �reverser� r r� rB � zip_longestrA rr Z silent_list);r- r r r r� r Z cumulativer~ Zhisttyper% r� Zrwidthr� r� rB Zstackedr rD Z bin_rangeZ input_emptyr( r6 r^ ZwiZ error_messageZ hist_kwargsr� r� Z_wZtopsZmlastrz r� ZdbrO Z_saved_autoscalexZ_saved_autoscaleyZtotwidthZdrr1 ZdwZboffsetZ_barfuncZ bottom_kwargrP r2 r� r� Zlogbaser- Zndatar? ZxvalsZyvalsr� r� rS Zlblr� r )r r- r� r �hist) s� \ � � � �� � $ �� �� >6 26 6�. � z Axes.histr r� c K s� t j||||||d�\} } } |dk r0d| | |k < |dk rDd| | |k< | j| | | jf| �} | �| d | d � | �| d | d � | | | | fS )a� Make a 2D histogram plot. Parameters ---------- x, y : array_like, shape (n, ) Input values bins : None or int or [int, int] or array_like or [array, array] The bin specification: - If int, the number of bins for the two dimensions (nx=ny=bins). - If ``[int, int]``, the number of bins in each dimension (nx, ny = bins). - If array_like, the bin edges for the two dimensions (x_edges=y_edges=bins). - If ``[array, array]``, the bin edges in each dimension (x_edges, y_edges = bins). The default value is 10. range : array_like shape(2, 2), optional, default: None The leftmost and rightmost edges of the bins along each dimension (if not specified explicitly in the bins parameters): ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range will be considered outliers and not tallied in the histogram. density : bool, optional, default: False Normalize histogram. *normed* is a deprecated synonym for this parameter. weights : array_like, shape (n, ), optional, default: None An array of values w_i weighing each sample (x_i, y_i). cmin : scalar, optional, default: None All bins that has count less than cmin will not be displayed and these count values in the return value count histogram will also be set to nan upon return cmax : scalar, optional, default: None All bins that has count more than cmax will not be displayed (set to none before passing to imshow) and these count values in the return value count histogram will also be set to nan upon return Returns ------- h : 2D array The bi-dimensional histogram of samples x and y. Values in x are histogrammed along the first dimension and values in y are histogrammed along the second dimension. xedges : 1D array The bin edges along the x axis. yedges : 1D array The bin edges along the y axis. image : `~.matplotlib.collections.QuadMesh` Other Parameters ---------------- cmap : Colormap or str, optional A `.colors.Colormap` instance. If not set, use rc settings. norm : Normalize, optional A `.colors.Normalize` instance is used to scale luminance data to ``[0, 1]``. If not set, defaults to `.colors.Normalize()`. vmin/vmax : None or scalar, optional Arguments passed to the `~.colors.Normalize` instance. alpha : ``0 <= scalar <= 1`` or ``None``, optional The alpha blending value. See also -------- hist : 1D histogram plotting Notes ----- - Currently ``hist2d`` calculates it's own axis limits, and any limits previously set are ignored. - Rendering the histogram with a logarithmic color scale is accomplished by passing a `.colors.LogNorm` instance to the *norm* keyword argument. Likewise, power-law normalization (similar in effect to gamma correction) can be accomplished with `.colors.PowerNorm`. )r r r r Nr rl )r Z histogram2drt rU ru rv )r- r r� r r r� r ZcminZcmaxrD r8 ZxedgesZyedgesZpcr r r �hist2dB s ` � z Axes.hist2dc K s |dkr d}t j|||||||| | d� \} }||7 }| dkrBd}nd}| j|dt�| � f| �}| �d� | �d | � | �d � | jj \}}|| }t t�|��}|dkr�d }d| }t� t � |�t �|�d |�}| �|� | dks�| s�| |fS | ||fS dS ) a� Plot the power spectral density. The power spectral density :math:`P_{xx}` by Welch's average periodogram method. The vector *x* is divided into *NFFT* length segments. Each segment is detrended by function *detrend* and windowed by function *window*. *noverlap* gives the length of the overlap between segments. The :math:`|\mathrm{fft}(i)|^2` of each segment :math:`i` are averaged to compute :math:`P_{xx}`, with a scaling to correct for power loss due to windowing. If len(*x*) < *NFFT*, it will be zero padded to *NFFT*. Parameters ---------- x : 1-D array or sequence Array or sequence containing the data %(Spectral)s %(PSD)s noverlap : int The number of points of overlap between segments. The default value is 0 (no overlap). Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. return_line : bool Whether to include the line object plotted in the returned values. Default is False. Returns ------- Pxx : 1-D array The values for the power spectrum `P_{xx}` before scaling (real valued). freqs : 1-D array The frequencies corresponding to the elements in *Pxx*. line : a :class:`~matplotlib.lines.Line2D` instance The line created by this function. Only returned if *return_line* is True. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s See Also -------- :func:`specgram` :func:`specgram` differs in the default overlap; in not returning the mean of the segment periodograms; in returning the times of the segments; and in plotting a colormap instead of a line. :func:`magnitude_spectrum` :func:`magnitude_spectrum` plots the magnitude spectrum. :func:`csd` :func:`csd` plots the spectral density between two signals. Notes ----- For plotting, the power is plotted as :math:`10\log_{10}(P_{xx})` for decibels, though *Pxx* itself is returned. References ---------- Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986) Nr ) r �NFFT�Fsr �window�noverlap�pad_to�sides� scale_by_freq)NTzdB/Hz�dBr � FrequencyzPower Spectral Density (%s)Tr� r )�mlab�psdr� r r rM rP r� �viewLimrK r r rq r �ceilrw )r- r r� r� �Fcr r� r� r� r� r� � return_linerD Zpxx�freqsZ psd_unitsr� r r �intvZlogir �ticksr r r r� � s8 V � zAxes.psdc K s� |dkr d}t j|||||||| | | d� \}}||7 }| j|dt�t�|�� f| �}| �d� | �d� | �d� | j j \}}|| }dt t�|�� }t� t �|�t �|�d |�}| �|� | dks�| s�||fS |||fS dS ) aj Plot the cross-spectral density. The cross spectral density :math:`P_{xy}` by Welch's average periodogram method. The vectors *x* and *y* are divided into *NFFT* length segments. Each segment is detrended by function *detrend* and windowed by function *window*. *noverlap* gives the length of the overlap between segments. The product of the direct FFTs of *x* and *y* are averaged over each segment to compute :math:`P_{xy}`, with a scaling to correct for power loss due to windowing. If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero padded to *NFFT*. Parameters ---------- x, y : 1-D arrays or sequences Arrays or sequences containing the data. %(Spectral)s %(PSD)s noverlap : int The number of points of overlap between segments. The default value is 0 (no overlap). Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. return_line : bool Whether to include the line object plotted in the returned values. Default is False. Returns ------- Pxy : 1-D array The values for the cross spectrum `P_{xy}` before scaling (complex valued). freqs : 1-D array The frequencies corresponding to the elements in *Pxy*. line : a :class:`~matplotlib.lines.Line2D` instance The line created by this function. Only returned if *return_line* is True. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s See Also -------- :func:`psd` :func:`psd` is the equivalent to setting y=x. Notes ----- For plotting, the power is plotted as :math:`10\log_{10}(P_{xy})` for decibels, though `P_{xy}` itself is returned. References ---------- Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986) Nr ) r r� r� r� r r� r� r� r� r� r r� z Cross Spectrum Magnitude (dB)Tr )r� �csdr� r r r� rM rP r� r� rK r r rq r r� rw )r- r r� r� r� r� r r� r� r� r� r� r� rD Zpxyr� r� r r r� r r� r r r r� % s, P � zAxes.csdc K s� |dkr d}|dks |dkr d}t j|||||d�\} } | |7 } |dkrR| } d} n&|dkrndt�| � } d} n td |��| j| | f|�} | �d � | �d | � | | | d fS ) a� Plot the magnitude spectrum. Compute the magnitude spectrum of *x*. Data is padded to a length of *pad_to* and the windowing function *window* is applied to the signal. Parameters ---------- x : 1-D array or sequence Array or sequence containing the data. %(Spectral)s %(Single_Spectrum)s scale : {'default', 'linear', 'dB'} The scaling of the values in the *spec*. 'linear' is no scaling. 'dB' returns the values in dB scale, i.e., the dB amplitude (20 * log10). 'default' is 'linear'. Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. Returns ------- spectrum : 1-D array The values for the magnitude spectrum before scaling (real valued). freqs : 1-D array The frequencies corresponding to the elements in *spectrum*. line : a :class:`~matplotlib.lines.Line2D` instance The line created by this function. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s See Also -------- :func:`psd` :func:`psd` plots the power spectral density.`. :func:`angle_spectrum` :func:`angle_spectrum` plots the angles of the corresponding frequencies. :func:`phase_spectrum` :func:`phase_spectrum` plots the phase (unwrapped angle) of the corresponding frequencies. :func:`specgram` :func:`specgram` can plot the magnitude spectrum of segments within the signal in a colormap. Nr rE r �r r� r� r� r� Zenergyr� � 4@�Unknown scale %sr� zMagnitude (%s))r� �magnitude_spectrumr r r9 r� rM rP )r- r r� r� r� r� r� �scalerD �specr� �ZZyunitsr� r r r r� � s( E � zAxes.magnitude_spectrumc K s^ |dkr d}t j|||||d�\}} | |7 } | j| |f|�} | �d� | �d� || | d fS )ag Plot the angle spectrum. Compute the angle spectrum (wrapped phase spectrum) of *x*. Data is padded to a length of *pad_to* and the windowing function *window* is applied to the signal. Parameters ---------- x : 1-D array or sequence Array or sequence containing the data. %(Spectral)s %(Single_Spectrum)s Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. Returns ------- spectrum : 1-D array The values for the angle spectrum in radians (real valued). freqs : 1-D array The frequencies corresponding to the elements in *spectrum*. line : a :class:`~matplotlib.lines.Line2D` instance The line created by this function. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s See Also -------- :func:`magnitude_spectrum` :func:`angle_spectrum` plots the magnitudes of the corresponding frequencies. :func:`phase_spectrum` :func:`phase_spectrum` plots the unwrapped version of this function. :func:`specgram` :func:`specgram` can plot the angle spectrum of segments within the signal in a colormap. Nr r� r� zAngle (radians))r� �angle_spectrumr� rM rP � r- r r� r� r� r� r� rD r� r� r� r r r r� � s < � zAxes.angle_spectrumc K s^ |dkr d}t j|||||d�\}} | |7 } | j| |f|�} | �d� | �d� || | d fS )a^ Plot the phase spectrum. Compute the phase spectrum (unwrapped angle spectrum) of *x*. Data is padded to a length of *pad_to* and the windowing function *window* is applied to the signal. Parameters ---------- x : 1-D array or sequence Array or sequence containing the data %(Spectral)s %(Single_Spectrum)s Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. Returns ------- spectrum : 1-D array The values for the phase spectrum in radians (real valued). freqs : 1-D array The frequencies corresponding to the elements in *spectrum*. line : a :class:`~matplotlib.lines.Line2D` instance The line created by this function. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s See Also -------- :func:`magnitude_spectrum` :func:`magnitude_spectrum` plots the magnitudes of the corresponding frequencies. :func:`angle_spectrum` :func:`angle_spectrum` plots the wrapped version of this function. :func:`specgram` :func:`specgram` can plot the phase spectrum of segments within the signal in a colormap. Nr r� r� zPhase (radians))r� �phase_spectrumr� rM rP r� r r r r� 6 s ; � zAxes.phase_spectrum� rh rE c K s\ t j|||||||| d�\} }||7 }| j|| f| � | �d� | �d� | �d� | |fS )a� Plot the coherence between *x* and *y*. Plot the coherence between *x* and *y*. Coherence is the normalized cross spectral density: .. math:: C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}} Parameters ---------- %(Spectral)s %(PSD)s noverlap : int The number of points of overlap between blocks. The default value is 0 (no overlap). Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. Returns ------- Cxy : 1-D array The coherence vector. freqs : 1-D array The frequencies for the elements in *Cxy*. Other Parameters ---------------- **kwargs Keyword arguments control the :class:`~matplotlib.lines.Line2D` properties: %(_Line2D_docstr)s References ---------- Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John Wiley & Sons (1986) )r r� r� r� r r� r� r� r� Z CoherenceT)r� �coherer� rM rP r� )r- r r� r� r� r� r r� r� r� r� r� rD Zcxyr� r r r r� ~ s 5 � z Axes.coherec K s� |dkr d}|dkrd}|dkr$d}| dkr4t d��|dksD|dkrX| dkrRd }qpd }n| dkrp|d krpt d ��tj||||||| | | | d � \}}}|d kr�|}nJ|d kr�| dks�| dks�| d kr�dt�|� }q�dt�|� }n t d|��t�|�}| dk�r,|| | d }t�|�| t�|�| f} | \}}||7 }|||d |d f}| j||f|||d�|��}| � d� ||||fS )a� Plot a spectrogram. Compute and plot a spectrogram of data in *x*. Data are split into *NFFT* length segments and the spectrum of each section is computed. The windowing function *window* is applied to each segment, and the amount of overlap of each segment is specified with *noverlap*. The spectrogram is plotted as a colormap (using imshow). Parameters ---------- x : 1-D array or sequence Array or sequence containing the data. %(Spectral)s %(PSD)s mode : {'default', 'psd', 'magnitude', 'angle', 'phase'} What sort of spectrum to use. Default is 'psd', which takes the power spectral density. 'magnitude' returns the magnitude spectrum. 'angle' returns the phase spectrum without unwrapping. 'phase' returns the phase spectrum with unwrapping. noverlap : int The number of points of overlap between blocks. The default value is 128. scale : {'default', 'linear', 'dB'} The scaling of the values in the *spec*. 'linear' is no scaling. 'dB' returns the values in dB scale. When *mode* is 'psd', this is dB power (10 * log10). Otherwise this is dB amplitude (20 * log10). 'default' is 'dB' if *mode* is 'psd' or 'magnitude' and 'linear' otherwise. This must be 'linear' if *mode* is 'angle' or 'phase'. Fc : int The center frequency of *x* (defaults to 0), which offsets the x extents of the plot to reflect the frequency range used when a signal is acquired and then filtered and downsampled to baseband. cmap A :class:`matplotlib.colors.Colormap` instance; if *None*, use default determined by rc xextent : *None* or (xmin, xmax) The image extent along the x-axis. The default sets *xmin* to the left border of the first bin (*spectrum* column) and *xmax* to the right border of the last bin. Note that for *noverlap>0* the width of the bins is smaller than those of the segments. **kwargs Additional kwargs are passed on to imshow which makes the specgram image. Returns ------- spectrum : 2-D array Columns are the periodograms of successive segments. freqs : 1-D array The frequencies corresponding to the rows in *spectrum*. t : 1-D array The times corresponding to midpoints of segments (i.e., the columns in *spectrum*). im : instance of class :class:`~matplotlib.image.AxesImage` The image created by imshow containing the spectrogram See Also -------- :func:`psd` :func:`psd` differs in the default overlap; in returning the mean of the segment periodograms; in not returning times; and in generating a line plot instead of colormap. :func:`magnitude_spectrum` A single spectrum, similar to having a single segment when *mode* is 'magnitude'. Plots a line instead of a colormap. :func:`angle_spectrum` A single spectrum, similar to having a single segment when *mode* is 'angle'. Plots a line instead of a colormap. :func:`phase_spectrum` A single spectrum, similar to having a single segment when *mode* is 'phase'. Plots a line instead of a colormap. Notes ----- The parameters *detrend* and *scale_by_freq* do only apply when *mode* is set to 'psd'. Nr� r � �complexz Cannot plot a complex specgramrE )ZangleZphaser r� z,Cannot use dB scale with angle or phase mode) r r� r� r r� r� r� r� r� r r� r r� r� rh rl )r' r r �auto) r9 r� �specgramr r Zflipudr r rq r� )r- r r� r� r� r r� r� r Zxextentr� r� r� r r� r r rD r� r� r� r� Z pad_xextentr� r� r' rp r r r r� � sT g � � z Axes.specgramrh r� c K s� |dkr |dkr t |d�r d}|dkr�|dkr�t�|�}t�|�|k}d|krdtjddgdd�|d< d |krttd ��| j|fd ||d �|��} �n t |d�r�|�� } |d kr�| j } | j } n$t�| j �|k} | j | } | j | } n&t�|�}t�|�|k} t� | �\} } |dk�rd}|dk�r"d}d|k�r4td��t j| | fd||d�|��}| �|� |j\}}| �d|d � | �|d d� | �|� |} | j�d� | j�� | j�d� | j�tjdddddgdd �� | j �tjdddddgdd �� | S ) a� Plot the sparsity pattern of a 2D array. This visualizes the non-zero values of the array. Two plotting styles are available: image and marker. Both are available for full arrays, but only the marker style works for `scipy.sparse.spmatrix` instances. **Image style** If *marker* and *markersize* are *None*, `~.Axes.imshow` is used. Any extra remaining kwargs are passed to this method. **Marker style** If *Z* is a `scipy.sparse.spmatrix` or *marker* or *markersize* are *None*, a `~matplotlib.lines.Line2D` object will be returned with the value of marker determining the marker type, and any remaining kwargs passed to `~.Axes.plot`. Parameters ---------- Z : array-like (M, N) The array to be plotted. precision : float or 'present', optional, default: 0 If *precision* is 0, any non-zero value will be plotted. Otherwise, values of :math:`|Z| > precision` will be plotted. For :class:`scipy.sparse.spmatrix` instances, you can also pass 'present'. In this case any value present in the array will be plotted, even if it is identically zero. origin : {'upper', 'lower'}, optional Place the [0,0] index of the array in the upper left or lower left corner of the axes. The convention 'upper' is typically used for matrices and images. If not given, :rc:`image.origin` is used, defaulting to 'upper'. aspect : {'equal', 'auto', None} or float, optional Controls the aspect ratio of the axes. The aspect is of particular relevance for images since it may distort the image, i.e. pixel will not be square. This parameter is a shortcut for explicitly calling `.Axes.set_aspect`. See there for further details. - 'equal': Ensures an aspect ratio of 1. Pixels will be square. - 'auto': The axes is kept fixed and the aspect is adjusted so that the data fit in the axes. In general, this will result in non-square pixels. - *None*: Use :rc:`image.aspect` (default: 'equal'). Default: 'equal' Returns ------- ret : `~matplotlib.image.AxesImage` or `.Line2D` The return type depends on the plotting style (see above). Other Parameters ---------------- **kwargs The supported additional parameters depend on the plotting style. For the image style, you can pass the following additional parameters of `~.Axes.imshow`: - *cmap* - *alpha* - *url* - any `.Artist` properties (passed on to the `.AxesImage`) For the marker style, you can pass any `.Line2D` property except for *linestyle*: %(_Line2D_docstr)s N�tocoor� r r6 r� Zbinary)r� rn z8spy() got an unexpected keyword argument 'interpolation'r� )rn rm ro Zpresentr r� z4spy() got an unexpected keyword argument 'linestyle'r )r� r r� r rc ��������?�both� r rh r[ T�ZnbinsZstepsZinteger) r� r r� r� r� ZListedColormaprV rq r� �rowrU rj �nonzeror� r� r� r� ru rv rn r5 �set_yrG �tick_top�set_ticks_positionr� r� � MaxNLocatorrN )r- r� Z precisionr r� rm ro rD r� r� rP r� r r� Zmarksr� r� r r r �spyX sz S � � �� � �� � �zAxes.spyc K s� t �|�}dddd�|�}| j|f|�}| j�d� | j�� | j�d� | j�t j ddd d d gd d �� | j �t j ddd d d gd d �� |S )a� Plot the values of a 2D matrix or array as color-coded image. The matrix will be shown the way it would be printed, with the first row at the top. Row and column numbering is zero-based. Parameters ---------- Z : array-like(M, N) The matrix to be displayed. Returns ------- image : `~matplotlib.image.AxesImage` Other Parameters ---------------- **kwargs : `~matplotlib.axes.Axes.imshow` arguments See Also -------- imshow : More general function to plot data on a 2D regular raster. Notes ----- This is just a convenience function wrapping `.imshow` to set useful defaults for a displaying a matrix. In particular: - Set ``origin='upper'``. - Set ``interpolation='nearest'``. - Set ``aspect='equal'``. - Ticks are placed to the left and above. - Ticks are formatted to show integer indices. r� r� rh )ro rn rm r� r� r� r rh r[ r Tr� ) r r� rq r5 r� rG r� r� r� r� r� rN )r- r� rD r8 rp r r r �matshow� s( $ �� � �z Axes.matshow�datasetc s4 � fdd�} t j|| |d�} | j| ||||||d�S )a� Make a violin plot. Make a violin plot for each column of *dataset* or each vector in sequence *dataset*. Each filled area extends to represent the entire data range, with optional lines at the mean, the median, the minimum, and the maximum. Parameters ---------- dataset : Array or a sequence of vectors. The input data. positions : array-like, default = [1, 2, ..., n] Sets the positions of the violins. The ticks and limits are automatically set to match the positions. vert : bool, default = True. If true, creates a vertical violin plot. Otherwise, creates a horizontal violin plot. widths : array-like, default = 0.5 Either a scalar or a vector that sets the maximal width of each violin. The default is 0.5, which uses about half of the available horizontal space. showmeans : bool, default = False If `True`, will toggle rendering of the means. showextrema : bool, default = True If `True`, will toggle rendering of the extrema. showmedians : bool, default = False If `True`, will toggle rendering of the medians. points : scalar, default = 100 Defines the number of points to evaluate each of the gaussian kernel density estimations at. bw_method : str, scalar or callable, optional The method used to calculate the estimator bandwidth. This can be 'scott', 'silverman', a scalar constant or a callable. If a scalar, this will be used directly as `kde.factor`. If a callable, it should take a `GaussianKDE` instance as its only parameter and return a scalar. If None (default), 'scott' is used. Returns ------- result : dict A dictionary mapping each component of the violinplot to a list of the corresponding collection instances created. The dictionary has the following keys: - ``bodies``: A list of the :class:`matplotlib.collections.PolyCollection` instances containing the filled area of each violin. - ``cmeans``: A :class:`matplotlib.collections.LineCollection` instance created to identify the mean values of each of the violin's distribution. - ``cmins``: A :class:`matplotlib.collections.LineCollection` instance created to identify the bottom of each violin's distribution. - ``cmaxes``: A :class:`matplotlib.collections.LineCollection` instance created to identify the top of each violin's distribution. - ``cbars``: A :class:`matplotlib.collections.LineCollection` instance created to identify the centers of each violin's distribution. - ``cmedians``: A :class:`matplotlib.collections.LineCollection` instance created to identify the median values of each of the violin's distribution. c s: t �| d | k�r$| d |k�t�S t�| � �}|�|�S )Nr )r �allr� r@ r� Z GaussianKDEZevaluate)r5 r� Zkde�� bw_methodr r � _kde_methodo s z$Axes.violinplot.<locals>._kde_method)�points)r� r� r� r� � showextrema� showmedians)r� Z violin_stats�violin) r- r� r� r� r� r� r� r� r� r� r� �vpstatsr r� r � violinplot s Y �zAxes.violinplotc C s g }g } g } g } i } t |�} d}|dkr8td| d �}nt |�| krRt|�d���t�|�rh|g| }nt |�| kr�t|�d���dt�|� | }dt�|� | }|r�| j}| j}| j }n| j }| j }| j}t d r�d }d }n| j � � }}g }t|||�D ]�\}}}t�|d �}d | | |�� }|||d | | || |dd�g7 }|�|d � | �|d � | �|d � | �|d � �q || d< |�r�|||||d�| d< |�r�|| |||d�| d< || |||d�| d< ||| | |d�| d< |�r || |||d�| d< | S )a� Drawing function for violin plots. Draw a violin plot for each column of `vpstats`. Each filled area extends to represent the entire data range, with optional lines at the mean, the median, the minimum, and the maximum. Parameters ---------- vpstats : list of dicts A list of dictionaries containing stats for each violin plot. Required keys are: - ``coords``: A list of scalars containing the coordinates that the violin's kernel density estimate were evaluated at. - ``vals``: A list of scalars containing the values of the kernel density estimate at each of the coordinates given in *coords*. - ``mean``: The mean value for this violin's dataset. - ``median``: The median value for this violin's dataset. - ``min``: The minimum value for this violin's dataset. - ``max``: The maximum value for this violin's dataset. positions : array-like, default = [1, 2, ..., n] Sets the positions of the violins. The ticks and limits are automatically set to match the positions. vert : bool, default = True. If true, plots the violins vertically. Otherwise, plots the violins horizontally. widths : array-like, default = 0.5 Either a scalar or a vector that sets the maximal width of each violin. The default is 0.5, which uses about half of the available horizontal space. showmeans : bool, default = False If true, will toggle rendering of the means. showextrema : bool, default = True If true, will toggle rendering of the extrema. showmedians : bool, default = False If true, will toggle rendering of the medians. Returns ------- result : dict A dictionary mapping each component of the violinplot to a list of the corresponding collection instances created. The dictionary has the following keys: - ``bodies``: A list of the :class:`matplotlib.collections.PolyCollection` instances containing the filled area of each violin. - ``cmeans``: A :class:`matplotlib.collections.LineCollection` instance created to identify the mean values of each of the violin's distribution. - ``cmins``: A :class:`matplotlib.collections.LineCollection` instance created to identify the bottom of each violin's distribution. - ``cmaxes``: A :class:`matplotlib.collections.LineCollection` instance created to identify the top of each violin's distribution. - ``cbars``: A :class:`matplotlib.collections.LineCollection` instance created to identify the centers of each violin's distribution. - ``cmedians``: A :class:`matplotlib.collections.LineCollection` instance created to identify the median values of each of the violin's distribution. zHList of violinplot statistics and `{0}` values must have the same lengthNr r� r� g пr� r] r� rQ r+ rc r� g333333�?)rd rf r� r r r� �bodies)r� ZcmeansZcmaxesZcminsZcbarsZcmedians)rU r r9 ra r r� r� ra r� r� r_ r r� r> r� r r� )r- r� r� r� r� r� r� r� r� r� r� r� r� r� r� ZpminsZpmaxesr? Z perp_linesZ par_linesZ fillcolorre r� r� rz r1 r+ r r r r� { s� [ � � � � � � z Axes.violin�ur~ Z start_points)r/ )Nr/ N)NN)NN)N)N)NF)r r r )r r r )r r )r r )r� r� r� )r� r� r� )r� r r NNr� )r� NTF)r$ N)r$ N)NNNNre Frf NNTNNrg FF) NNr� NNNFFFFFr N)NNNNNNNNNNNNNNNNNNNNNNTFN)NNTFFFTTTNNNNNNFTN) NNNNNNNNNNN)r NFN)r NNF)NNNNNNNNNNr rc NNN)NNNNFNrS r r� NFNNFN)r NFNNN) NNNNNNNNNN) NNNNNNNNNN)NNNNNN)NNNNN)NNNNN)NNNNNNNNNNNNNNN)r NNrh r� )NTrc FTFr3 N)NTrc FTF)r�__name__� __module__� __qualname__�__doc__r� Z deprecated�propertyr. r< rF rJ rM rO rP rT � docstringZdedent_interpdrZ rX r^ rg r{ r� r� Z_delete_parameterr� r� r� r� �__init__r� r� r� r� r r� r� r� r� r� r r r r r� Z detrend_noner r � staticmethodr# rS rT rV rc r| rI Z_rename_parameterr� r� r� r r r� r0 r1 r9 r2 r3 Z quiverkey_docr: r= r; Z quiver_docr> r? r_ ra rq ry rz rt r� r� r� r� Z _contour_docr� r� Z ContourSetr� r� r� r� r� r� r� Zwindow_hanningr� r� r� r� r� r� �mtable�table�mstack� stackplot�mstream� streamplot�mtriZ tricontourZ tricontourfZ tripcolorZtriplotr r r r r* a sH ? nC � j+'! V E D 7 @ � � J � � K � � Y oL 6 0 / > � hC 3 *p I � : � l � � � # � ~ �� �� Y � I 0 5 � 5 � 5 � DC� j � T� M � �l �s �h �\ �G �F �? � � 5 � d � 3 ��r* )NN)]Zcollections.abcr� r� rB Zloggingrq r� Znumbersr Znumpyr r Z matplotlibr r Zmatplotlib.cbookr� Zmatplotlib.collectionsr� Zmatplotlib.colorsr� r� Zmatplotlib.contourr� r� Zmatplotlib.category�categoryr� Zmatplotlib.datesZdatesZmatplotlib.docstringr� Zmatplotlib.imager� rg Zmatplotlib.legendrZ rQ Zmatplotlib.linesr� r� Zmatplotlib.markersZmarkersr� Zmatplotlib.mlabr� Zmatplotlib.pathr� r� Zmatplotlib.patchesrO rn Zmatplotlib.quiverr= r2 Zmatplotlib.stackplotr� r� Zmatplotlib.streamplotr� r� Zmatplotlib.tabler� r� Zmatplotlib.textr� r� Zmatplotlib.tickerZtickerr� Zmatplotlib.transformsZ transformsr Zmatplotlib.triZtrir� Zmatplotlib.containerr r r Zmatplotlib.axes._baser r Z matplotlib.axes._secondary_axesr Znumpy.lib.histogramsr � ImportErrorZ getLoggerr� r� r) r* r r r r �<module> sR