|
Server : Apache System : Linux server112.speedpacket.com 3.10.0-962.3.2.lve1.5.36.el7.x86_64 #1 SMP Mon May 18 02:16:06 EDT 2020 x86_64 User : equistyl ( 1341) PHP Version : 8.1.30 Disable Function : NONE Directory : /lib64/python2.7/site-packages/matplotlib/ |
Upload File : |
�
r`]c @ sA d d l m Z m Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l Z d d l
Z d d l
m Z d d l
Z
e
j Z d d l j Z d d l m Z d d l j Z d d l j Z d d l j Z d d l j Z d d l j Z d d l! j" Z# d d l
m$ Z$ d d l% j& Z& d d l' j( Z) d d l* j+ Z, d d l- j. Z/ d d l0 j1 Z2 d d l3 j4 Z4 d d l5 j6 Z7 d d l8 j9 Z: d d l; j< Z= d d l> j? Z@ d d lA jB ZC d d lD jE ZF d d lG jH ZI d d lJ jK ZL d d lM jN ZO d d lP jQ ZR d d lS jT ZU d d lV jW ZX d d lY mZ ZZ m[ Z[ m\ Z\ e j] Z] e j^ Z^ e j_ Z_ d � Z` d � Za d
� Zb d ec f d � � YZd d
e je f d � � YZf d d lg mh Zh mi Zi d f d � � YZj i Zk el d � Zm em � Zn d ec f d � � YZo e$ jp jq d
e jr ef � � e$ jp jq d e jr ef � � d S( i����( t divisiont print_functionN( t
itemgetter( t ma( t allow_rasterization( t docstring( t BarContainert ErrorbarContainert
StemContainerc C s@ t | � s | S| d k r t S| d k r0 t St d � � d S( Nt ont offs, string argument must be either 'on' or 'off'( t is_string_liket Truet Falset
ValueError( t s( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _string_to_bool- s c C s] d } d } d } yi t j j | � } y t t | � � } Wn t k
rZ | | | f SX| | k rt | | | f Sd } Wn t k
r� n X| j d � d k r� d } | j d d � } n | j d � d k r� d } | j d d � } n | j d � d k r d } | j d d � } n g | D] } | ^ q&} x� | D]� } | t j
k r|| d k rst d | � � n | } q?| t j k r�| d k r�t d | � � n | } q?| t j j k r�| d k r�t d | � � n | } q?t d
| � � q?W| d k r&| d k r&t
d } n | d k r;d } n | d k rPd } n | | | f S(
s�
Process a MATLAB style color/line style format string. Return a
(*linestyle*, *color*) tuple as a result of the processing. Default
values are ('-', 'b'). Example format strings include:
* 'ko': black circles
* '.b': blue dots
* 'r--': red dashed lines
.. seealso::
:func:`~matplotlib.Line2D.lineStyles` and
:func:`~matplotlib.pyplot.colors`
for all possible styles and color format string.
s --i t s -.t t Nones1 Illegal format string "%s"; two linestyle symbolss. Illegal format string "%s"; two marker symbolss- Illegal format string "%s"; two color symbolss* Unrecognized character %c in format strings lines.linestyleN( R t mcolorst colorConvertert to_rgbt strt intR t findt replacet mlinest
lineStylest lineMarkerst colorst rcParams( t fmtt linestylet markert colort fmtintt ct chars( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _process_plot_format6 sb
c C s | t d <t j d t � d S( s�
Change the default cycle of colors that will be used by the plot
command. This must be called before creating the
:class:`Axes` to which it will apply; it will
apply to all future axes.
*clist* is a sequence of mpl color specifiers.
See also: :meth:`~matplotlib.axes.Axes.set_color_cycle`.
.. Note:: Deprecated 2010/01/03.
Set rcParams['axes.color_cycle'] directly.
s axes.color_cycles) Set rcParams['axes.color_cycle'] directlyN( R t warningst warnt DeprecationWarning( t clist( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_default_color_cycle� s
t _process_plot_var_argsc B s� e Z d Z d d � Z d � Z d � Z d d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z RS( s3
Process variable length arguments to the plot command, so that
plot commands like the following are supported::
plot(t, s)
plot(t1, s1, t2, s2)
plot(t1, s1, 'ko', t2, s2)
plot(t1, s1, 'ko', t2, s2, 'r--', t3, e3)
an arbitrary number of *x*, *y*, *fmt* are allowed
t plotc C s | | _ | | _ | j � d S( N( t axest commandt set_color_cycle( t selfR/ R0 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __init__� s c C s i | j d 6| j d 6S( NR/ R0 ( R/ R0 ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __getstate__� s c C s | j � | _ | j � d S( N( t copyt __dict__R1 ( R2 t state( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __setstate__� s c C s/ | d k r t d } n t j | � | _ d S( Ns axes.color_cycle( R R t itertoolst cyclet color_cycle( R2 R+ ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR1 � s
c O s | j j d k r| j j d k r| j d | j j j � } | j j d k rf | j d | � } n | j d | j j j � } | j j d k r� | j d | � } n | | j j j k r� | j j j | � n | | j j j k r| j j j | � qn | j | | � } | S( Nt xunitst polart
thetaunitst yunitst runits( R/ t xaxisR t yaxist popt unitst namet set_unitst _grab_next_args( R2 t argst kwargsR< R? t ret( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __call__� s $c K sf x_ | j � D]Q \ } } d | } t | | � sE t d | � � n t | | � } | | � q
Wd S( Ns set_%ss There is no line property "%s"( t itemst hasattrt TypeErrort getattr( R2 t lineRI t keyt valt funcNamet func( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
set_lineprops� s
c K sf x_ | j � D]Q \ } } d | } t | | � sE t d | � � n t | | � } | | � q
Wd S( Ns set_%ss There is no patch property "%s"( RL RM RN RO ( R2 t fill_polyRI RQ RR RS RT ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_patchprops� s
c C sm | j j d k r� | j j d k r� | j j j | � } | j j j | � } | j d k r� | rx | j j | � } n | r� | j j | � } q� q� n t j | � } t j | � } | j
d | j
d k r� t d � � n | j d k s� | j d k r
t d � � n | j d k r8| d d � t j
f } n | j d k rc| d d � t j
f } n | | f S( NR. i s& x and y must have same first dimensioni s" x and y can be no greater than 2-Di ( R/ RA R RB t update_unitsR0 t convert_xunitst convert_yunitst npt
atleast_1dt shapeR t ndimt newaxis( R2 t xt yt bxt by( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _xy_from_xy� s& $
c C sr | j � } d | k r@ d | j � k r@ | j j � | d <n t j | | d | j | �} | j | | � | S( NR# R/ ( R5 t keysR; t nextR t Line2DR/ RU ( R2 R` Ra t kwRI t seg( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _makeline s c C s� y | d } Wn t k
r0 | j j � } n Xt j t j | d d � t j f | d d � t j f f � d | d t d | d �} | j | | � | S( NR# t facecolort fillt closed(
t KeyErrorR; Rf t mpatchest PolygonR[ t hstackR_ R RW ( R2 R` Ra Rh RI Rk Ri ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _makefill s
5
c C s� g } t | � d k rN t | d � rN t | d � \ } } } | d } n0 t | � d k ro t d � � n d
\ } } } i } x? t d | | | f � D]% \ } } | d k r� | | | <q� q� Wt j | d � }
t | � d k rt j | d � } n t j |
j d d
t
�} | j | |
� \ } }
| j d k rP| j
} n | j d t � | d <| j } | j d |
j d }
} xg t t |
| � � D]P } | | d d � | |
f |
d d � | | f | | � } | j | � q�W| S( Ni i����i s! third arg must be a format stringR! R" R# i i t dtypeR. Rm ( NNN( s linestyles markers color( t lenR R' R R t zipR[ R\ t arangeR] t floatRd R0 Rj t getR Rr t xranget maxt append( R2 t tupRI RJ R! R" R# Rh t kt vRa R` RT t ncxt ncyt jRi ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
_plot_args s4 "
=c o s� | } x� t | � d k r d St | � d k rW x | j | | � D] } | VqD Wd St | d � rp d } n d } x# | j | | | � D] } | Vq� W| | } q d S( Ni i i ( Rt R� R ( R2 RH RI t remainingRi t isplit( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRG B s N( t __name__t
__module__t __doc__R3 R4 R8 R R1 RK RU RW Rd Rj Rr R� RG ( ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR- � s $
$t Axesc B s�
e Z d Z d Z e j � Z e j � Z d � Z e e
e e d e e d � Z d � Z d � Z
d � Z d � Z d � Z d
d � Z d � Z d
� Z d
d � Z d � Z d � Z d � Z e d � Z d d � Z d � Z d � Z d � Z d � Z d � Z e d d d � Z d � Z! d � Z" e# e" � Z$ d � Z% d � Z& d! � Z' e d" � Z( d# � Z) e e d$ � Z* d% � Z+ d& � Z, d' � Z- d( � Z. d) � Z/ d* � Z0 e d+ � Z1 d, � Z2 d- � Z3 d. � Z" d/ � Z4 d0 � Z5 d1 � Z6 d2 � Z7 d3 � Z8 d4 � Z9 d5 � Z: d6 � Z; d7 � Z< d8 � Z= d9 � Z> d: � Z? d; � Z@ e
d< � ZA d= � ZB d> � ZC d? � ZD d@ � ZE dA � ZF dB � ZG dC � ZH e
e
dD � ZI dE � ZJ dF � ZK e e e dG � ZL dH � ZM dI � ZN dJ � ZO dK � ZP dL � ZQ dM � ZR dN � ZS dO � ZT dP � ZU dQ � ZV dR � ZW dS � ZX e
d e dT � ZY e e
e
dU � ZZ e[ e e dV � � Z\ dW � Z] dX � Z^ dY � Z_ dZ � Z` d[ � Za d\ � Zb d] � Zc d^ � Zd ee jf e d_ d d` � � Zg da � Zh d e db � Zi d dc � Zj dd � Zk de � Zl df � Zm dg � Zn dh � Zo di � Zp dj � Zq e e dk � Zr dl � Zs e e e
e dm � Zt dn � Zu do dp jv ew jx � � eu _ ee jf dq � � Zy e dr � Zz e ds � Z{ dt � Z| du � Z} e dv � Z~ ee jf e e dw � � Z dx � Z� dy � Z� dz � Z� e e d{ � Z� d| � Z� e e e
e d} � Z� d~ � Z� d dp jv ew jx � � e� _ ee jf d� � � Z� e d� � Z� e d� � Z� d� � Z� d� � Z� e d� � Z� ee jf e e d� � � Z� e d� � Z� e d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� e e d� � Z� d� � Z� ee jf e d� � � Z� d� � Z� ee jf e e d� � � Z� d� � Z� ee jf e e d� � � Z� ee jf e e d� � � Z� ee jf d� � � Z� ee jf d� d� d� d� � � Z� ee jf d� d� d� d� � � Z� ee jf d� d� d� � � Z� ee jf d� d� d� � � Z� ee j� d� d� d d� � � Z� ee jf d� d� d d� � � Z� ee jf d� � � Z� ee jf d� e e
e d� � � Z� ee jf d� � � Z� ee jf d� � � Z� ee jf d� � � Z� ee jf d� � � Z� ee jf e
e� j� e
d� d� � � Z� e d� � Z� e d� � Z� d� � Z� d� � Z� ee jf d� e d� � � Z� ee jf d� e d� � � Z� ee jf d� � � Z� d� d� d� e e d� � Z� e e e e d� e d� e e d� � Z� ee jf e e d� e e d� e e e e e d� e d� �
� Z� e d� e
d� e e e e e e d� �
Z� ee jf d� d� d� e e e e e e e
e d� � � Z� ee jf e d� e d� d� e e e e e e e d� e� j� e e d� � � Z� ee jf d� � � Z� d� � Z� e� j� j� e� _ d� � Z� e� j� j� e� _ d� � Z� e� j� j e� _ d� e e e e d� d� d� e d� � Z� e� j� j e� _ ee jf d� � � Z� ee jf d� � � Z� ee jf d� e e d� � � Z� ee jf d� e d� � � Z� ee jf e e e e e e e e e e d� d� e e e d� � � Z� d� � Z� ee jf d� � � Z� ee jf d� � � Z� ee jf d� � � Z� d� � Z� e� j� j� e� _ d� � Z� e� j� j� e� _ d� � Z� e� j� j� j e� _ ee jf d� � � Z� d� � Z� d� � Z� d� � Z� d� � Z� d� � Z� ee jf d� e e e e e d� d� d� e e e e e d� � � Z� ee jf d� e e e e e d� � � Z� ee jf d� d� d� e� j� e� j� d� e d� e d� � � Z� ee jf d� d� d� e� j� e� j� d� e d� e d� � � Z� ee jf d� d� d� e� j� e� j� d� e d� e d� � � Z� ee jf d� d� d� e� j� e� j� d� e e e d� e d� � � Z� d� e e d� d� � Z� d� � Z� d� � Z� e
d � Z� d� Z� d� Z� d� Z� e� j� j� e� _ d� Z� e� j� j� e� _ d� Z e� j j e _ d� Ze� jj e_ RS( sa
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.
t rectilinearc C s d t | j j � S( Ns Axes(%g,%g;%gx%g)( t tuplet _positiont bounds( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __str__k s R c
K s� d i d j g t j � D] } t | � ^ q � d 6t j j | � t | t j � re | | _
n t j j | � | _
| j
j � | _
| j | � | j d � d | _ | j d � | | _ | | _ | d k r| j j | | � | j d k rd | _ n d | _ n | d k rZ| j j | | � | j d k rNd | _ n d | _ n | j | � | j | � | j |
j d d � � | j � | _ | j � | d k r�t d } n | | _ | | _ t d
| _! d | _" t d | _# i | _$ | j% � d | _& d | _' | j( d � d | _) | j* t+ � | j, d � | r_| j- | � n | ru| j. | � n t/ |
� r�t j0 | |
� n | j1 d k r�| j1 j2 j3 d | j4 � | _5 n | j6 d k r�| j6 j2 j3 d | j4 � | _7 n d S( Ns5
Build an :class:`Axes` instance in
:class:`~matplotlib.figure.Figure` *fig* with
*rect=[left, bottom, width, height]* in
:class:`~matplotlib.figure.Figure` coordinates
Optional keyword arguments:
================ =========================================
Keyword Description
================ =========================================
*adjustable* [ 'box' | 'datalim' | 'box-forced']
*alpha* float: the alpha transparency (can be None)
*anchor* [ 'C', 'SW', 'S', 'SE', 'E', 'NE', 'N',
'NW', 'W' ]
*aspect* [ 'auto' | 'equal' | aspect_ratio ]
*autoscale_on* [ *True* | *False* ] whether or not to
autoscale the *viewlim*
*axis_bgcolor* any matplotlib color, see
:func:`~matplotlib.pyplot.colors`
*axisbelow* draw the grids and ticks below the other
artists
*cursor_props* a (*float*, *color*) tuple
*figure* a :class:`~matplotlib.figure.Figure`
instance
*frame_on* a boolean - draw the axes frame
*label* the axes label
*navigate* [ *True* | *False* ]
*navigate_mode* [ 'PAN' | 'ZOOM' | None ] the navigation
toolbar button status
*position* [left, bottom, width, height] in
class:`~matplotlib.figure.Figure` coords
*sharex* an class:`~matplotlib.axes.Axes` instance
to share the x-axis with
*sharey* an class:`~matplotlib.axes.Axes` instance
to share the y-axis with
*title* the title string
*visible* [ *True* | *False* ] whether the axes is
visible
*xlabel* the xlabel
*xlim* (*xmin*, *xmax*) view limits
*xscale* [%(scale)s]
*xticklabels* sequence of strings
*xticks* sequence of floats
*ylabel* the ylabel strings
*ylim* (*ymin*, *ymax*) view limits
*yscale* [%(scale)s]
*yticklabels* sequence of strings
*yticks* sequence of floats
================ =========================================
s | t scalet autot boxt Ct datalimt axes_locators axes.facecolors axes.axisbelows axes.holdi R} s units finalize( i R} (8 t joint mscalet get_scale_namest reprt martistt ArtistR3 t
isinstancet mtransformst BboxR� t from_boundst frozent _originalPositiont set_axest
set_aspectt _adjustablet
set_anchort _sharext _shareyR t _shared_x_axest _shared_y_axest set_labelt
set_figuret set_axes_locatorRx t _gen_axes_spinest spinest
_init_axisR t _axisbgt _frameont
_axisbelowt _rasterization_zordert _holdt
_connectedt clat fmt_xdatat fmt_ydatat set_cursor_propst _cachedRenderert set_navigateR t set_navigate_modet
set_xscalet
set_yscaleRt t setpRA t callbackst connectt relimt _xcidRB t _ycid( R2 t figt rectt axisbgt frameont sharext shareyt labelt xscalet yscaleRI R` ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR3 n sl <7
c C s\ | | _ xL d d d d d d g D]2 } t | | � } x | D] } | j | _ q> Wq" Wd S( Nt linest collectionst tablest patchest textst images( R6 RO t removet _remove_method( R2 R7 t container_namet containert artist( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR8 � s
c O s | j S( sc
get the axes bounding box in display space; *args* and
*kwargs* are empty
( t bbox( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_window_extent� s c C s� t j | � | _ | j d j | j � | j d j | j � t j | � | _ | j d j | j � | j d j | j � | j � d S( sA move this out of __init__ because non-separable axes don't use itt bottomt topt leftt rightN( t maxist XAxisRA R� t
register_axist YAxisRB t _update_transScale( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s c C sx t j j | | � t j | j | j � | _ t j j � | _
t j j � | _ t j t j
� � | _ | j � d S( s|
Set the class:`~matplotlib.axes.Axes` figure
accepts a class:`~matplotlib.figure.Figure` instance
N( R� R� R� R� t TransformedBboxR� t transFigureR� R� t unitt dataLimt viewLimt TransformWrappert IdentityTransformt
transScalet _set_lim_and_transforms( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s c C s� t j | j � | _ t j t j � � | _ t j t j | j | j � � | _
| j | j
| j | _ t j | j | j � | _
t j | j | j � | _ d S( sB
set the *dataLim* and *viewLim*
:class:`~matplotlib.transforms.Bbox` attributes and the
*transScale*, *transData*, *transLimits* and *transAxes*
transformations.
.. note::
This method is primarily used by rectilinear projections
of the :class:`~matplotlib.axes.Axes` class, and is meant
to be overridden by new kinds of projection axes that need
different transformations and limits. (See
:class:`~matplotlib.projections.polar.PolarAxes` for an
example.
N( R� t BboxTransformToR� t transAxesR� R� R� t BboxTransformFromR� R� t transLimitst transDatat blended_transform_factoryt _xaxis_transformt _yaxis_transform( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s t gridc C s] | d k r | j S| d k r0 | j d j � S| d k rM | j d j � St d � � d S( s�
Get the transformation used for drawing x-axis labels, ticks
and gridlines. The x-direction is in data coordinates and the
y-direction is in axis coordinates.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is meant to be
overridden by new kinds of projections that may need to
place axis elements in different locations.
R� t tick1R� t tick2R� s unknown value for whichN( R� R� t get_spine_transformR ( R2 t which( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xaxis_transformG s c C s: | j d d � t j d d | d | j j � d d f S( s�
Get the transformation used for drawing x-axis labels, which
will add the given amount of padding (in points) between the
axes and the label. The x-direction is in data coordinates
and the y-direction is in axis coordinates. Returns a
3-tuple of the form::
(transform, valign, halign)
where *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is meant to be
overridden by new kinds of projections that may need to
place axis elements in different locations.
R� R� i i����g R@R� t center( R� R� t ScaledTranslationt figuret dpi_scale_trans( R2 t
pad_points( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xaxis_text1_transform` s
c C s6 | j d d � t j d | d | j j � d d f S( s�
Get the transformation used for drawing the secondary x-axis
labels, which will add the given amount of padding (in points)
between the axes and the label. The x-direction is in data
coordinates and the y-direction is in axis coordinates.
Returns a 3-tuple of the form::
(transform, valign, halign)
where *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is meant to be
overridden by new kinds of projections that may need to
place axis elements in different locations.
R� R� i g R@R� R� ( R� R� R� R� R� ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xaxis_text2_transformz s
c C s] | d k r | j S| d k r0 | j d j � S| d k rM | j d j � St d � � d S( s�
Get the transformation used for drawing y-axis labels, ticks
and gridlines. The x-direction is in axis coordinates and the
y-direction is in data coordinates.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is meant to be
overridden by new kinds of projections that may need to
place axis elements in different locations.
R� R� R� R� R� s unknown value for whichN( R� R� R� R ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yaxis_transform� s c C s: | j d d � t j d | d d | j j � d d f S( s�
Get the transformation used for drawing y-axis labels, which
will add the given amount of padding (in points) between the
axes and the label. The x-direction is in axis coordinates
and the y-direction is in data coordinates. Returns a 3-tuple
of the form::
(transform, valign, halign)
where *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is meant to be
overridden by new kinds of projections that may need to
place axis elements in different locations.
R� R� i����g R@i R� R� ( R R� R� R� R� ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yaxis_text1_transform� s
c C s6 | j d d � t j | d d | j j � d d f S( s�
Get the transformation used for drawing the secondary y-axis
labels, which will add the given amount of padding (in points)
between the axes and the label. The x-direction is in axis
coordinates and the y-direction is in data coordinates.
Returns a 3-tuple of the form::
(transform, valign, halign)
where *valign* and *halign* are requested alignments for the
text.
.. note::
This transformation is primarily used by the
:class:`~matplotlib.axis.Axis` class, and is meant to be
overridden by new kinds of projections that may need to
place axis elements in different locations.
R� R� g R@i R� R� ( R R� R� R� R� ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yaxis_text2_transform� s
c C s} | j j t j | j j � | j j � � � t | d � ry x9 | j D]+ } y | j j
� WqG t k
rq qG XqG Wn d S( NR� ( R� t setR� R� RA t
get_transformRB RM R� t _transformed_patht
invalidatet AttributeError( R2 RP ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s
c C s$ | r | j j � S| j j � Sd S( s1 Return the a copy of the axes rectangle as a BboxN( R� R� R� ( R2 t original( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_position� s
t bothc C si t | t j � s' t j j | � } n | d k rF | j j | � n | d k re | j j | � n d S( s�
Set the axes position with::
pos = [left, bottom, width, height]
in relative 0,1 coords, or *pos* can be a
:class:`~matplotlib.transforms.Bbox`
There are two position variables: one which is ultimately
used, but which may be modified by :meth:`apply_aspect`, and a
second which is the starting point for :meth:`apply_aspect`.
Optional keyword arguments:
*which*
========== ====================
value description
========== ====================
'active' to change the first
'original' to change the second
'both' to change both
========== ====================
R
t activeR N( R
R ( R
s original( R� R� t BboxBaseR� R� R� R R� ( R2 t posR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_position� s c C s) | j d t � } | j | d d �d S( s. Make the original position the active positionR R� R N( R R R ( R2 R
( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt reset_position s c C s
| | _ d S( s�
set axes_locator
ACCEPT : a callable object which takes an axes instance and renderer and
returns a bbox.
N( t
_axes_locator( R2 t locator( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s c C s | j S( s%
return axes_locator
( R ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_axes_locator# s c C s@ | j | j � | j � s/ | j | j � n | j | � d S( s3 set the boilerplate props for artists added to axesN( R� R� t is_transform_sett
set_transformR� R� ( R2 t a( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _set_artist_props) s c C s t j d d d � S( s]
Returns the patch used to draw the background of the axes. It
is also used as the clipping path for any data elements on the
axes.
In the standard axes, this is a rectangle, but in other
projections it may not be.
.. note::
Intended to be overridden by new projection types.
g g �?( g g ( Ro t Rectangle( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _gen_axes_patch1 s g t inchesc C s\ i t j j | d � d 6t j j | d � d 6t j j | d � d 6t j j | d � d 6S( si
Returns a dict whose keys are spine names and values are
Line2D or Patch instances. Each element is used to draw a
spine of the axes.
In the standard axes, this is a single line segment, but in
other projections it may not be.
.. note::
Intended to be overridden by new projection types.
R� R� R� R� ( t mspinest Spinet linear_spine( R2 t locationst offsetRD ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� A s
c
C s� | j j � | j j � x' | j j � D] \ } } | j � q* Wt | _ t j � | _ | j
d k rm| j
j j | j _ | j
j j
| j _
| j
j � \ } } | j | | d t d d �| j
j j � } | j
j j � } | j
j j � } | j
j j � } | j j | j
j j � � | j j | � | j j | � | j j | � | j j | � n | j j d � | j d k r�| j j j | j _ | j j j
| j _
| j j � \ } }
| j | |
d t d d �| j j j � } | j j j � } | j j j � } | j j j � } | j j | j j j � � | j j | � | j j | � | j j | � | j j | � n | j j d � t | _ t | _ d | _ d | _! t | _" | j# � t$ | � | _% t$ | d � | _& t' d | _( g | _) g | _* g | _+ g | _, g | _- g | _. d | _/ d | _0 g | _1 g | _2 | j3 | j( � t4 j5 d t' d � } t6 j7 d d | j8 j9 � | _: t; j< d d
d d d d d | d d d d � | _= | j= j> | j? | j: � | j= j@ d � | jA | j= � | jB � | _C | _D | jC jE | j8 � | jC jF | jG � | jC jH d � | jC jI d � | jC j> | j? � t | _J | j jK | jC � | j jK | jC � | jL jM � | jN jM � d S( s Clear the current axes.t emitR� t lineari Rl s axes.gridt sizes axes.titlesizeg g @g R@R` g �?Ra g �?t textR t fontpropertiest verticalalignmentt baselinet horizontalalignmentR� R Ngr �q DZ?(O RA R� RB R� t iteritemsR t ignore_existing_data_limitst cbookt CallbackRegistryR� R� R t majort minort get_xlimt set_xlimR
t get_major_formattert get_minor_formattert get_major_locatort get_minor_locatort set_scalet get_scalet set_major_formattert set_minor_formattert set_major_locatort set_minor_locatorR� t get_ylimt set_ylimt
_autoscaleXont
_autoscaleYont _xmargint _ymargint _tightR� R- t
_get_linest _get_patches_for_fillR t _gridOnR� R� R� R� t artistsR� t _current_imaget legend_R� t
containersR� t font_managert FontPropertiesR� R� R� R� t titleOffsetTranst mtextt Textt titleR R� t set_clip_boxR R t patcht axesPatchR� t
set_facecolorR� t
set_edgecolort
set_linewidtht axisont
set_clip_pathR� t cleanR� ( R2 RE t spinet x0t x1t majft minft majlt minlt y0t y1t props( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� V s�
c C s t d � � d S( Ns. Axes.frame was removed in favor of Axes.spines( R ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_frame� s c C s | j � d S( s clear the axesN( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt clear� s c C s$ | j j | � | j j | � d S( s�
Set the color cycle for any future plot commands on this Axes.
*clist* is a list of mpl color specifiers.
N( R@ R1 RA ( R2 R+ ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR1 � s c C s | j S( s" return the HOLD status of the axes( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt ishold� s c C s) | d k r | j | _ n | | _ d S( s/
Call signature::
hold(b=None)
Set the hold state. If *hold* is *None* (default), toggle the
*hold* state. Else set the *hold* state to boolean value *b*.
Examples::
# toggle hold
hold()
# turn hold on
hold(True)
# turn hold off
hold(False)
When hold is *True*, subsequent plot commands will be added to
the current axes. When hold is *False*, the current axes and
figure will be cleared on the next plot command
N( R R� ( R2 t b( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt hold� s c C s | j S( N( t _aspect( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_aspect s c C s{ | d k r d | _ n' | d k r0 d | _ n t | � | _ | d k r[ | j | � n | d k rw | j | � n d S( s�
*aspect*
======== ================================================
value description
======== ================================================
'auto' automatic; fill position rectangle with data
'normal' same as 'auto'; deprecated
'equal' same scaling from data to plot units for x and y
num a circle will be stretched such that the height
is num times the width. aspect=1 is the same as
aspect='equal'.
======== ================================================
*adjustable*
============ =====================================
value description
============ =====================================
'box' change physical size of axes
'datalim' change xlim or ylim
'box-forced' same as 'box', but axes can be shared
============ =====================================
'box' does not allow axes sharing, as this can cause
unintended side effect. For cases when sharing axes is
fine, use 'box-forced'.
*anchor*
===== =====================
value description
===== =====================
'C' centered
'SW' lower left corner
'S' middle of bottom edge
'SE' lower right corner
etc.
===== =====================
t normalR� t equalN( Rg s auto( Re Rw R t set_adjustableR� ( R2 t aspectt
adjustablet anchor( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s * c C s | j S( N( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_adjustable9 s c C sd | d k rT | | j k s* | | j k rH | d k rH t d � � qH n | | _ n t d � � d S( s>
ACCEPTS: [ 'box' | 'datalim' | 'box-forced']
R� R� s
box-forceds, adjustable must be "datalim" for shared axess$ argument must be "box", or "datalim"N( s boxs datalims
box-forced( R� R� R R� ( R2 Rk ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRi < s c C s | j S( N( t _anchor( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_anchorI s c C s_ | t j j j � k s* t | � d k r6 | | _ n% t d d j t j j j � � � � d S( su
*anchor*
===== ============
value description
===== ============
'C' Center
'SW' bottom left
'S' bottom
'SE' bottom right
'E' right
'NE' top right
'N' top
'NW' top left
'W' left
===== ============
i s argument must be among %ss , N( R� R� t coefsRe Rt Rn R R� ( R2 Rl ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� L s * c C sd | j � \ } } | j � \ } } t t j | | � d � } t t j | | � d � } | | S( s�
Returns the aspect ratio of the raw data.
This method is intended to be overridden by new projection
types.
g���KH�9( t
get_xboundt
get_yboundRz t matht fabs( R2 t xmint xmaxt ymint ymaxt xsizet ysize( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_data_ratioe s
c C s� | j � \ } } | j � \ } } t t j t j | � t j | � � d � } t t j t j | � t j | � � d � } | | S( s
Returns the aspect ratio of the raw data in log scale.
Will be used when both axis scales are in log.
g���KH�9( Rq Rr Rz Rs Rt t log10( R2 Ru Rv Rw Rx Ry Rz ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_data_ratio_logu s
..c 0 C s� | d k r! | j d t � } n | j � } | j d k r� | j � | j � } } | d k rv | d k rv d } q� | d k r� | d k r� d } q� | d k r� | d k s� | d k r� | d k r� | d k r� t j d | | f � d } q� q� n d } | d k r"| j | d d �d S| d
k r7d } n | } | | j
k s[| | j k r�| j d k r�d
| _ t j d � q�n | j
� j � \ } } | | } | j d k r-| d k r�| | j � }
n | | j � }
| j � } | j |
| | � } | j | j | j � | � d � d S| j | d d �| j � \ }
} | j � \ } } | d k r�t j |
� t j | � }
} t j | � t j | � } } n t t j | |
� d � } t t j | | � d � } | j \ } } } } | | | }
|
| } | | | d } t | � d k r>d S| d k r�| j } t j | j � t j | j � } t j | j � t j | j! � } d | } d | } n# | j } d | j" } d | j# } | | } | | } | | } | | }! |! | }" | | }# d }$ d }% | | j k o4| | j
k }& | | j
k oR| | j k }' |& rr|' rrt j d � d S|& r�t$ }( nc | |$ k r�| |% k r�|# d k r�| d k p�|" d k o�| d k }) n | d k }) |' p�|) }( |( rTd | | }* |* | d }+ |* | d }, | d k r>| j% d |+ d |, f � q�| j% |+ |, f � ng d |
| }- |- |! d }. |- |! d }/ | d k r�| j& d |. d |/ f � n | j& |. |/ f � d S( sp
Use :meth:`_aspect` and :meth:`_adjustable` to modify the
axes box or the view limits.
R R= R t logR� s: aspect is not supported for Axes with xscale=%s, yscale=%sR� R NRh i R� R� s7 shared axes: "adjustable" is being changed to "datalim"s
box-forcedg���KH�9g �?g{�G�zt?g�������?i s9 adjustable='datalim' cannot work with shared x and y axesg �?g @g $@( s boxs
box-forced(' R R R Rf RE t
get_xscalet
get_yscaleR( R) R R� R� R� t
get_figuret get_size_inchesR} R{ R� t shrunk_to_aspectt anchoredRo Rq Rr Rs R| Rz Rt R� t absR� RX RW R^ R] t widtht heightR
t
set_yboundt
set_xbound(0 R2 t positionRj R� R� t aspect_scale_modet At figWt figHt
fig_aspectt
box_aspectt pbt pb1Ru Rv Rw Rx Ry Rz t lRc t wt ht
data_ratiot
y_expandert dLt dL_widtht dL_heightt xrt yrt xmargt ymargt Ysizet Xsizet Xmargt Ymargt xmt ymt changext changeyt adjust_yt adjyt ycR] R^ t xcRW RX ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt apply_aspect� s�
" "
""
c
O s� t | � d k rX t | � d k rX | j � \ } } | j � \ } } | | | | f St | � d k rt | d � r| d j � } | d k r� | j � n*| d k r� | j � n| d k r�| j t � | j d � | j
d t � | d k r| j d d d �q�| d k rI| j d d d
d d �| j t � q�| d k ru| j
d t � | j t � q�| d
k r�| j
d t � | j t � | j d d d
d d �q�n t d | � � | j � \ } } | j � \ } } | | | | f S| j
d t � } y | d Wn� t k
r | j
d d � } | j
d d � } t } | d k rz| d k rzd } n | j | | d | d | �\ } } | j
d d � } | j
d d � } t } | d k r�| d k r�d } n | j | | d | d | �\ } } | | | | f SX| d } t | � d k rIt d � � n | j | d | d g d | d t �| j | d | d g d | d t �| S( s
Convenience method for manipulating the x and y view limits
and the aspect ratio of the plot. For details, see
:func:`~matplotlib.pyplot.axis`.
*kwargs* are passed on to :meth:`set_xlim` and
:meth:`set_ylim`
i i R R
Rh t tightt scaledRg R� t imageRk R� R� Rl R� s- Unrecognized string %s to axis; try on or offR Ru Rv Rw Rx i s$ v must contain [xmin xmax ymin ymax]i i ( s equals tightR� s normals autoR� N( Rt R- R9 R t lowert set_axis_ont set_axis_offt set_autoscale_onR R� t autoscale_viewR
R Rx t
IndexErrorR R. R: (
R2 R~ RI Ru Rv Rw Rx R R R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt axis sl $"
$ $
''c C s t d � � d S( s[
Return a list of artists the axes contains.
.. deprecated:: 0.98
s Use get_children insteadN( R* ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_child_artists] s c C s t j d t � | j S( s Return the axes Rectangle frames use ax.patch instead( R( R) R* RN ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR` e s c C s | j S( sB Return the legend.Legend instance, or None if no legend is defined( RE ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_legendj s c C s t j d | j � S( s2 return a list of Axes images contained by the Axest AxesImage( R) t silent_listR� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_imagesn s c C s t j d | j � S( s, Return a list of lines contained by the AxesRg ( R) R� R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_linesr s c C s | j S( s Return the XAxis instance( RA ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xaxisv s c C s t j d | j j � � S( s2 Get the x grid lines as a list of Line2D instancess Line2D xgridline( R) R� RA t
get_gridlines( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xgridlinesz s c C s t j d | j j � � S( s1 Get the xtick lines as a list of Line2D instancess Text xtickline( R) R� RA t
get_ticklines( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xticklines s c C s | j S( s Return the YAxis instance( RB ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yaxis� s c C s t j d | j j � � S( s2 Get the y grid lines as a list of Line2D instancess Line2D ygridline( R) R� RB R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_ygridlines� s c C s t j d | j j � � S( s1 Get the ytick lines as a list of Line2D instancess Line2D ytickline( R) R� RB R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yticklines� s c C sw t | t j j � r= | j d | j k rj t d � � qj n- | | j k rj | | j k rj t d � � n | | _ d S( sZ
helper for :func:`~matplotlib.pyplot.sci`;
do not use elsewhere.
i s" ContourSet must be in current AxessA Argument must be an image, collection, or ContourSet in this AxesN( R� t
matplotlibt contourt
ContourSetR� R R� RD ( R2 t im( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _sci� s c C s | j S( sZ
Helper for :func:`~matplotlib.pyplot.gci`;
do not use elsewhere.
( RD ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _gci� s c C s: t | j � t | j � t | j � t | j � d k S( s�
Return *True* if any artists have been added to axes.
This should not be used to determine whether the *dataLim*
need to be updated, and may not actually be useful for
anything.
i ( Rt R� R� R� R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt has_data� s &c sP | j � � � j j | � � j | � | j � j � � f d � | _ | S( sf
Add any :class:`~matplotlib.artist.Artist` to the axes.
Returns the artist.
c s � j j | � S( N( RC R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt <lambda>� s ( R� RC R{ R RT RN R� ( R2 R ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
add_artist� s
c s� | j � } | s/ | j d t � j � � n � j j | � � j | � | j � d k rq | j � j � n | r� | j
r� t | j
� r� � j | j � j
� � q� n � f d � | _ | S( s�
Add a :class:`~matplotlib.collections.Collection` instance
to the axes.
Returns the collection.
s
_collection%dc s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s N( t get_labelR� Rt R� R{ R t
get_clip_pathR RT RN t _pathst update_datalimt get_datalimR� R� ( R2 t
collectiont autolimR� ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt add_collection� s
c s� � j | � | j � d k r2 | j � j � n � j | � | j � sh | j d t � j � � n � j j
| � � f d � | _ | S( sv
Add a :class:`~matplotlib.lines.Line2D` to the list of plot
lines
Returns the line.
s _line%dc s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s N( R R� R RT RN t _update_line_limitsR� R� Rt R� R{ R� ( R2 RP ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt add_line� s
c C s | j � } | j j d k r" d S| j � } | | j k rF | } ny t | j | j � � r� | | j } | j j r� | j � } | j � \ } } | j
| � } q� | j | � } n | } | j j d k r| j | j � \ } }
| j j
| | j d | d |
�t | _ n d S( sD Figures out the data limit of the given line, updating self.dataLim.i Nt updatext updatey( t get_patht verticesR! R R� t anyt contains_branch_seperatelyt is_affinet _get_transformed_patht get_transformed_path_and_affinet transform_path_affinet transform_pathR� t update_from_pathR( R
( R2 RP t patht
line_transt data_patht
trans_to_datat line_trans_patht na_patht _R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s,
c se � j | � | j � d k r2 | j � j � n � j | � � j j | � � f d � | _ | S( s
Add a :class:`~matplotlib.patches.Patch` *p* to the list of
axes patches; the clipbox will be set to the Axes clipping
box. If the transform is not set, it will be set to
:attr:`transData`.
Returns the patch.
c s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� $ s N( R R� R RT RN t _update_patch_limitsR� R{ R� ( R2 t p( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt add_patch s
c C s� t | t j � r0 | j � s, | j � r0 d S| j � j } | j d k r� | j � j | � } | j
� | j k r� | j
� | j } | j | � } n | j � j
| j � \ } } | j | d | d | �n d S( s$ update the data limits for patch *p*Ni R� R� ( R� Ro R t get_widtht
get_heightR� R� R! t get_patch_transformt transformt get_data_transformR� R R� R� ( R2 RN R� t xyst
patch_to_dataR� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� ' s
c sC � j | � � j j | � | j � j � � f d � | _ | S( s�
Add a :class:`~matplotlib.tables.Table` instance to the
list of axes tables
Returns the table.
c s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� J s ( R R� R{ RT RN R� ( R2 t tab( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt add_table@ s
c sY | j � } | s/ | j d t � j � � n � j j | � | j � f d � � | S( s
Add a :class:`~matplotlib.container.Container` instance
to the axes.
Returns the collection.
s _container%dc s � j j | � S( N( RF R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� X s ( R� R� Rt RF R{ t set_remove_method( R2 R� R� ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
add_containerM s c C s_ | j j t � t | _ x | j D] } | j | � q# Wx | j D] } | j | � qD Wd S( s�
Recompute the data limits based on current artists.
At present, :class:`~matplotlib.collections.Collection`
instances are not supported.
N( R� t ignoreR R( R� R� R� R� ( R2 RP R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� \ s c C sm t | � r t | � r d St j | � s> t j | � } n | j j | | j d | d | �t | _ d S( s@ Update the data lim bbox with seq of xy tups or equiv. 2-D arrayNR� R� (
t iterableRt R t
isMaskedArrayR[ t asarrayR� t update_from_data_xyR( R
( R2 R� R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� m s
c C sC t | � r t | � r d S| j j | | | j � t | _ d S( s, Update the data lim bbox with seq of xy tupsN( R� Rt R� t update_from_dataR( R
( R2 R` Ra ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt update_datalim_numerix{ s c C s) | j j t j j | j | g � � d S( so
Update the datalim to include the given
:class:`~matplotlib.transforms.Bbox` *bounds*
N( R� R R� R� t union( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt update_datalim_bounds� s c C s� | j d k s | j d k r" d S| d k rS | j j � sS | j j | � qS n | d k r� | j j � s� | j j | � q� n | d k r�| j d | j j � } | j d k r� | j d | � } n | | j j k r| j j | � | d k r| j j | � qn | j d | j j � } | j d k rL| j d | � } n | | j j k r�| j j | � | d k r�| j j | � q�q�n d S( sA Look for unit *kwargs* and update the axis instances as necessaryNR< R= R> R? R@ ( RA R RB t
have_unitsRX RC RD RE RF ( R2 t xdatat ydataRI R< R? ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _process_unit_info� s. c C s | j j | � d S( sd
Return *True* if the given *mouseevent* (in display coords)
is in the Axes
i ( RN t contains( R2 t
mouseevent( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt in_axes� s c C s | j o | j S( sS
Get whether autoscaling is applied for both axes on plot commands
( R; R< ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_autoscale_on� s c C s | j S( sT
Get whether autoscaling for the x-axis is applied on plot commands
( R; ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_autoscalex_on� s c C s | j S( sT
Get whether autoscaling for the y-axis is applied on plot commands
( R< ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_autoscaley_on� s c C s | | _ | | _ d S( sl
Set whether autoscaling is applied on plot commands
accepts: [ *True* | *False* ]
N( R; R< ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s c C s
| | _ d S( s{
Set whether autoscaling for the x-axis is applied on plot commands
accepts: [ *True* | *False* ]
N( R; ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_autoscalex_on� s c C s
| | _ d S( s{
Set whether autoscaling for the y-axis is applied on plot commands
accepts: [ *True* | *False* ]
N( R< ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_autoscaley_on� s c C s4 | d k s | d k r' t d � � n | | _ d S( s�
Set padding of X data limits prior to autoscaling.
*m* times the data interval will be added to each
end of that interval before it is used in autoscaling.
accepts: float in range 0 to 1
i i s margin must be in range 0 to 1N( R R= ( R2 t m( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_xmargin� s c C s4 | d k s | d k r' t d � � n | | _ d S( s�
Set padding of Y data limits prior to autoscaling.
*m* times the data interval will be added to each
end of that interval before it is used in autoscaling.
accepts: float in range 0 to 1
i i s margin must be in range 0 to 1N( R R> ( R2 R
( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_ymargin� s c O s | r | r | j | j f S| j d t � } | j d d
� } | j d d
� } t | � d k rw | d } } n- t | � d k r� | \ } } n t d � � | d
k r� | j | � n | d
k r� | j | � n | d
k } | d
k } | j d | d | d | � d
S( s*
Set or retrieve autoscaling margins.
signatures::
margins()
returns xmargin, ymargin
::
margins(margin)
margins(xmargin, ymargin)
margins(x=xmargin, y=ymargin)
margins(..., tight=False)
All three forms above set the xmargin and ymargin parameters.
All keyword parameters are optional. A single argument
specifies both xmargin and ymargin. The *tight* parameter
is passed to :meth:`autoscale_view`, which is executed after
a margin is changed; the default here is *True*, on the
assumption that when margins are specified, no additional
padding to match tick marks is usually desired. Setting
*tight* to *None* will preserve the previous setting.
Specifying any margin changes only the autoscaling; for example,
if *xmargin* is not None, then *xmargin* times the X data
interval will be added to each end of that interval before
it is used in autoscaling.
R� R` Ra i i i s% more than two arguments were suppliedt scalext scaleyN(
R= R> RC R R Rt R R R R� ( R2 RH Rh R� t mxt myR R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt margins s" # c C s
| | _ d S( s�
Set zorder value below which artists will be rasterized. Set
to `None` to disable rasterizing of artists below a particular
zorder.
N( R� ( R2 t z( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_rasterization_zorder= s c C s | j S( sI
Get zorder value below which artists will be rasterized
( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_rasterization_zorderE s c C s� | d k r t } t } nZ t } t } | d k rN t | � | _ | j } n | d k ru t | � | _ | j } n | j d | d | d | � d S(
s�
Autoscale the axis view to the data (toggle).
Convenience method for simple axis view autoscaling.
It turns autoscaling on or off, and then,
if autoscaling for either axis is on, it performs
the autoscaling on the specified axis or axes.
*enable*: [True | False | None]
True (default) turns autoscaling on, False turns it off.
None leaves the autoscaling state unchanged.
*axis*: ['x' | 'y' | 'both']
which axis to operate on; default is 'both'
*tight*: [True | False | None]
If True, set view limits to data limits;
if False, let the locator and margins expand the view limits;
if None, use tight scaling if the only artist is an image,
otherwise treat *tight* as False.
The *tight* setting is retained for future autoscaling
until it is explicitly changed.
Returns None.
R` R
Ra R� R R N( R` s both( Ra s both( R R R
t boolR; R< R� ( R2 t enableR� R� R R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt autoscaleK s c C s� | d k rW | j pQ t | j � d k oQ t | j � d k oQ t | j � d k } n t | � } | _ | r�| j r�| j j | � } g | D] } | j
^ q� } t j j
| � } | j \ } }
| j j � } y | j | |
� \ } }
Wn5 t k
r*t j | |
d t d d �\ } }
n X| j d k rb|
| | j } | | 8} |
| 7}
n | s�| j | |
� \ } }
n | j | |
� n | r�| j r�| j j | � }
g |
D] } | j
^ q�} t j j
| � } | j \ } } | j j � } y | j | | � \ } } Wn5 t k
rVt j | | d t d d �\ } } n X| j d k r�| | | j } | | 8} | | 7} n | s�| j | | � \ } } n | j | | � n d S( s
Autoscale the view limits using the data limits. You can
selectively autoscale only a single axis, eg, the xaxis by
setting *scaley* to *False*. The autoscaling preserves any
axis direction reversal that has already been done.
The data limits are not updated automatically when artist
data are changed after the artist has been added to an
Axes instance. In that case, use
:meth:`matplotlib.axes.Axes.relim`
prior to calling autoscale_view.
i t
increasingt expanderg�������?N( R R? Rt R� R� R� R R; R� t get_siblingsR� R� R R� t intervalxRA R1 t nonsingularR R
R= t view_limitsR� R< R� t intervalyRB R> R� ( R2 R� R R R? t xsharedt axt dlt bbRW RX t xlocatort deltat ysharedR] R^ t ylocator( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� u sR
c C s8 | d k r | j } n | d k r3 t d � � n | j � sC d S| j d � | j � } | r� | | | � } | j | � n
| j � g } | j | j � | j | j � | j | j
� | j | j � | j | j � | j
rY| rY| j r | j j d � | j j d � n | j j d � | j j d � | j | j | j g � n | sr| j | j � n | j | j � | j d k r�| j | j � n | j
r�| j r�| j | j j � � n g | D]! } | j � s�| j | f ^ q�} t | j � d k s | j � rS| j g | j D] } | j | f ^ q.� t } n t } | j d t! d � � | j" }
|
d k r t | � d k r | d d |
k r | j# � g | D] } | d |
k r�| ^ q�} g | D] } | d |
k r�| ^ q�} n g } | j
r4| j r4| j$ j% | � n | r�g | j D]! } | j � rD| j | f ^ qD}
|
j d d � � | j& � } g |
D]$ \ } } | j' | � d d f ^ q�} | j( j) \ } } } } | t* | � d t* | � d } | t* | � d t* | � d } t+ j, | | | � } t | _- | j( j. \ } } } } | j/ � } | j0 | j( � | j1 t2 j3 | j$ j4 � | j$ j5 � � � | j6 | t* | � t* | � | � | j7 � n | r�x! | D] \ } } | j% | � q�W| j8 � n x! | D] \ } } | j% | � qW| j9 d � | | _ d S(
s* Draw everything (plot lines, axes, labels)s No renderer definedNR/ g �?g @i RQ i c S s | d S( Ni ( ( R` ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s (: R R� t RuntimeErrort get_visiblet
open_groupR R� t extendR� R� R� R� RC RS R� RA t
set_zorderRB R{ RL R� RE R� R� t
itervaluest get_animatedt zorderRt R� t option_image_nocompositeR
R t sortR R� t start_rasterizingRN t drawt get_image_magnificationt
make_imageR� t extentst roundt mimaget from_imagest is_grayscaleR� t new_gct set_clip_rectangleRT R� t TransformedPathR� R t
draw_imaget restoret stop_rasterizingt close_group( R2 t renderert inframeR R
RC R t dsuR� t
_do_compositet rasterization_zorderR� t dsu_rasterizedt
zorder_imagest magR t imsRc t rt tR� R� R� R� t gcR1 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR5 � s�
!!, &
),! 1"" "
c C s | j | j � d S( s�
This method can only be used after an initial draw which
caches the renderer. It is used to efficiently update Axes
data (axis ticks, labels, etc are not updated)
N( R5 R� ( R2 R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt draw_artist+ s c C s | j | j d t �d S( s�
This method can only be used after an initial draw which
caches the renderer. It is used to efficiently update Axes
data (axis ticks, labels, etc are not updated)
RE N( R5 R� R ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt redraw_in_frame4 s c C s | j S( N( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_renderer_cache= s c C s� | j d k r t d � � n g | j j � D] } | j | f ^ q. } | j d d � � | j } | j � x! | D] \ } } | j | � qv Wd S( Ns You must first call ax.draw()RQ c S s | d S( Ni ( ( R` ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� E s ( t
_lastRendererR R* t animatedRe R1 R3 t blitR5 ( R2 R RF RD t tmp( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __draw_animate@ s +
c C s | j S( s?
Get whether the axes rectangle patch is drawn
( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_frame_onM s c C s
| | _ d S( sf
Set whether the axes rectangle patch is drawn
ACCEPTS: [ *True* | *False* ]
N( R� ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_frame_onS s c C s | j S( s7
Get whether axis below is true or not
( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_axisbelow[ s c C s
| | _ d S( s�
Set whether the axis ticks and gridlines are above or below most artists
ACCEPTS: [ *True* | *False* ]
N( R� ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
set_axisbelowa s R+ c K s� t | � r t } n t | � } | d k s9 | d k rU | j j | d | | �n | d k sm | d k r� | j j | d | | �n d S( s�
Turn the axes grids on or off.
Call signature::
grid(self, b=None, which='major', axis='both', **kwargs)
Set the axes grids on or off; *b* is a boolean. (For MATLAB
compatibility, *b* may also be a string, 'on' or 'off'.)
If *b* is *None* and ``len(kwargs)==0``, toggle the grid state. If
*kwargs* are supplied, it is assumed that you want a grid and *b*
is thus set to *True*.
*which* can be 'major' (default), 'minor', or 'both' to control
whether major tick grids, minor tick grids, or both are affected.
*axis* can be 'both' (default), 'x', or 'y' to control which
set of gridlines are drawn.
*kwargs* are used to set the grid line properties, eg::
ax.grid(color='r', linestyle='-', linewidth=2)
Valid :class:`~matplotlib.lines.Line2D` kwargs are
%(Line2D)s
R` R
R� Ra N( Rt R R RA R� RB ( R2 Rc R� R� RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� i s c
K s | j d d � j � } | j d d � } | j d d � } | j d d � } | j d d � j � } | d k r� y | \ } } | | d Wq� t t f k
r� t d � � q� Xn | d
d k r� t } n] | d k r t } | d k r� t }
q-t }
t d � � n! | d k r!d } n t d � � y�| d k r�| d k sT| d k rm| j j j
j | � n | d k s�| d k r�| j j j
j | � q�n | d k r| d k s�| d k r�| j j j
j
| � n | d k s�| d k r| j j j
j
| � qn | d k r�| d k s6| d k rO| j j j
j | � n | d k sg| d k r�| j j j
j | � q�n | d k r�| d k s�| d k r�| j j j
j | � n | d k s�| d k r�| j j j
j | � q�n Wn t k
rt d � � n Xd S( s
Change the `~matplotlib.ticker.ScalarFormatter` used by
default for linear axes.
Optional keyword arguments:
============ =========================================
Keyword Description
============ =========================================
*style* [ 'sci' (or 'scientific') | 'plain' ]
plain turns off scientific notation
*scilimits* (m, n), pair of integers; if *style*
is 'sci', scientific notation will
be used for numbers outside the range
10`m`:sup: to 10`n`:sup:.
Use (0,0) to include all numbers.
*useOffset* [True | False | offset]; if True,
the offset will be calculated as needed;
if False, no offset will be used; if a
numeric offset is specified, it will be
used.
*axis* [ 'x' | 'y' | 'both' ]
*useLocale* If True, format the number according to
the current locale. This affects things
such as the character used for the
decimal separator. If False, use
C-style (English) formatting. The
default setting is controlled by the
axes.formatter.use_locale rcparam.
============ =========================================
Only the major ticks are affected.
If the method is called when the
:class:`~matplotlib.ticker.ScalarFormatter` is not the
:class:`~matplotlib.ticker.Formatter` being used, an
:exc:`AttributeError` will be raised.
t styleR t scilimitst useOffsett useLocaleR� R
i s* scilimits must be a sequence of 2 integersi t scit plaint commas comma style remains to be addeds %s is not a valid style valueR` Ra s0 This method only works with the ScalarFormatter.N( Ra Rb ( RC R� R R RN R R
t NotImplementedErrorRA R+ t formattert set_scientificRB t set_powerlimitst
set_useOffsett
set_useLocaleR ( R2 RI R\ R] R^ R_ R� R
t nt sbt cb( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt ticklabel_format� s\ '
c K sv | d k } | d k } | r7 | j j � j | � n | rV | j j � j | � n | j d | d | d | � d S(
s�
Control behavior of tick locators.
Keyword arguments:
*axis*
['x' | 'y' | 'both'] Axis on which to operate;
default is 'both'.
*tight*
[True | False | None] Parameter passed to :meth:`autoscale_view`.
Default is None, for no change.
Remaining keyword arguments are passed to directly to the
:meth:`~matplotlib.ticker.MaxNLocator.set_params` method.
Typically one might want to reduce the maximum number
of ticks and use tight bounds when plotting small
subplots, for example::
ax.locator_params(tight=True, nbins=4)
Because the locator is involved in autoscaling,
:meth:`autoscale_view` is called automatically after
the parameters are changed.
This presently works only for the
:class:`~matplotlib.ticker.MaxNLocator` used
by default on linear axes, but it may be generalized.
R` R
Ra R� R R N( R` s both( Ra s both( RA R1 t
set_paramsRB R� ( R2 R� R� RI t _xt _y( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt locator_params� s c K s� | d
k rk t | � } | j d d � | j d d � | j d d � | j d d � | j j | � n | d k r� t | � } | j d d � | j d d � | j d
d � | j d d � | j j | � n d S( s�
Change the appearance of ticks and tick labels.
Keyword arguments:
*axis* : ['x' | 'y' | 'both']
Axis on which to operate; default is 'both'.
*reset* : [True | False]
If *True*, set all parameters to defaults
before processing other keyword arguments. Default is
*False*.
*which* : ['major' | 'minor' | 'both']
Default is 'major'; apply arguments to *which* ticks.
*direction* : ['in' | 'out']
Puts ticks inside or outside the axes.
*length*
Tick length in points.
*width*
Tick width in points.
*color*
Tick color; accepts any mpl color spec.
*pad*
Distance in points between tick and label.
*labelsize*
Tick label font size in points or as a string (e.g. 'large').
*labelcolor*
Tick label color; mpl color spec.
*colors*
Changes the tick color and the label color to the same value:
mpl color spec.
*zorder*
Tick and label zorder.
*bottom*, *top*, *left*, *right* : [bool | 'on' | 'off']
controls whether to draw the respective ticks.
*labelbottom*, *labeltop*, *labelleft*, *labelright*
Boolean or ['on' | 'off'], controls whether to draw the
respective tick labels.
Example::
ax.tick_params(direction='out', length=6, width=2, colors='r')
This will make all major ticks be red, pointing out of the box,
and with dimensions 6 points by 2 points. Tick labels will
also be red.
R` R
R� R� t labelleftt
labelrightRa R� R� t labeltopt labelbottomN( R` s both( Ra s both( t dictRC R RA t set_tick_paramsRB ( R2 R� RI t xkwt ykw( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt tick_params s = c C s
t | _ d S( s turn off the axisN( R
RS ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� \ s c C s
t | _ d S( s turn on the axisN( R RS ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� ` s c C s | j S( s Return the axis background color( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_axis_bgcolord s c C s | | _ | j j | � d S( s�
set the axes background color
ACCEPTS: any matplotlib color - see
:func:`~matplotlib.pyplot.colors`
N( R� RN RP ( R2 R# ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_axis_bgcolorh s c C s& | j � \ } } | j | | � d S( s Invert the x-axis.N( R- R. ( R2 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt invert_xaxisu s c C s | j � \ } } | | k S( s) Returns *True* if the x-axis is inverted.( R- ( R2 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt xaxis_invertedz s c C s6 | j � \ } } | | k r( | | f S| | f Sd S( sa
Returns the x-axis numerical bounds where::
lowerBound < upperBound
N( R- ( R2 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRq s
c C s� | d k r' t | � r' | \ } } n | j � \ } } | d k rN | } n | d k rc | } n | j � r� | | k r� | j | | d d �q� | j | | d d �n; | | k r� | j | | d d �n | j | | d d �d S( s�
Set the lower and upper numerical bounds of the x-axis.
This method will honor axes inversion regardless of parameter order.
It will not change the _autoscaleXon attribute.
R� N( R R� Rq R} R. ( R2 R� t uppert old_lowert old_upper( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s c C s t | j j � S( s8
Get the x-axis range [*left*, *right*]
( R� R� R ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR- � s c K sO d | k r | j d � } n d | k r< | j d � } n | r[ t d | j � � � n | d k r� t | � r� | \ } } n | j d | | f � | d k r� | j | � } n | d k r� | j | � } n | j � \ } } | d k r� | } n | d k r| } n | | k r>t j d d d | | f � n t
j | | d t �\ } } | j
j | | � \ } } | | f | j _ | d k r�t | � | _ n | rE| j j d | � x� | j j | � D]k } | | k r�| j | j j d
t d | �| j | j k r>| j j d k r>| j j j � q>q�q�Wn | | f S(
s�
Call signature::
set_xlim(self, *args, **kwargs):
Set the data limits for the xaxis
Examples::
set_xlim((left, right))
set_xlim(left, right)
set_xlim(left=1) # right unchanged
set_xlim(right=1) # left unchanged
Keyword arguments:
*left*: scalar
The left xlim; *xmin*, the previous name, may still be used
*right*: scalar
The right xlim; *xmax*, the previous name, may still be used
*emit*: [ *True* | *False* ]
Notify observers of limit change
*auto*: [ *True* | *False* | *None* ]
Turn *x* autoscaling on (*True*), off (*False*; default),
or leave unchanged (*None*)
Note, the *left* (formerly *xmin*) value may be greater than
the *right* (formerly *xmax*).
For example, suppose *x* is years before present.
Then one might use::
set_ylim(5000, 0)
so 5000 years ago is on the left of the plot and the
present is on the right.
Returns the current xlimits as a length 2 tuple
ACCEPTS: length 2 sequence of floats
Ru Rv s unrecognized kwargs: %sR s0 Attempting to set identical left==right results
s6 in singular transformations; automatically expanding.
s left=%s, right=%sR t xlim_changedR R� N( RC R Re R R� R RY R- R( R) R� R R
RA t limit_range_for_scaleR� R R R; R� t processR� R R. R� t canvast draw_idle( R2 R� R� R R� Rh t old_leftt old_rightt other( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR. � sH ,
c C s
| j j � S( N( RA R4 ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR
s s! Return the xaxis scale string: %ss , c K s1 | j j | | � | j d t � | j � d S( s�
Call signature::
set_xscale(value)
Set the scaling of the x-axis: %(scale)s
ACCEPTS: [%(scale)s]
Different kwargs are accepted, depending on the scale:
%(scale_docs)s
R N( RA R3 R� R
R� ( R2 t valueRI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR�
s c C s | j j d | � S( s) Return the x ticks as a list of locationsR, ( RA t get_ticklocs( R2 R, ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_xticks
s c C s | j j | d | �S( s[
Set the x ticks with list of *ticks*
ACCEPTS: sequence of floats
R, ( RA t set_ticks( R2 t ticksR, ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
set_xticks
s c C s t j d | j j � � S( se
Get the xtick labels as a list of :class:`~matplotlib.text.Text`
instances.
s Text xticklabel( R) R� RA t get_majorticklabels( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xmajorticklabels&
s c C s t j d | j j � � S( sk
Get the x minor tick labels as a list of
:class:`matplotlib.text.Text` instances.
s Text xticklabel( R) R� RA t get_minorticklabels( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xminorticklabels.
s c C s t j d | j j d | � � S( sf
Get the x tick labels as a list of :class:`~matplotlib.text.Text`
instances.
s Text xticklabelR, ( R) R� RA t get_ticklabels( R2 R, ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_xticklabels6
s c K s | j j | | d | | �S( so
Call signature::
set_xticklabels(labels, fontdict=None, minor=False, **kwargs)
Set the xtick labels with list of strings *labels*. Return a
list of axis text instances.
*kwargs* set the :class:`~matplotlib.text.Text` properties.
Valid properties are
%(Text)s
ACCEPTS: sequence of strings
R, ( RA t set_ticklabels( R2 t labelst fontdictR, RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_xticklabels>
s c C s& | j � \ } } | j | | � d S( s Invert the y-axis.N( R9 R: ( R2 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt invert_yaxisQ
s c C s | j � \ } } | | k S( s) Returns *True* if the y-axis is inverted.( R9 ( R2 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt yaxis_invertedV
s c C s6 | j � \ } } | | k r( | | f S| | f Sd S( sE Return y-axis numerical bounds in the form of lowerBound < upperBoundN( R9 ( R2 R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRr [
s
c C s� | d k r' t | � r' | \ } } n | j � \ } } | d k rN | } n | d k rc | } n | j � r� | | k r� | j | | d d �q� | j | | d d �n; | | k r� | j | | d d �n | j | | d d �d S( s�
Set the lower and upper numerical bounds of the y-axis.
This method will honor axes inversion regardless of parameter order.
It will not change the _autoscaleYon attribute.
R� N( R R� Rr R� R: ( R2 R� R~ R R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� c
s c C s t | j j � S( s8
Get the y-axis range [*bottom*, *top*]
( R� R� R! ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR9 |
s c K s9 d | k r | j d � } n d | k r< | j d � } n | r[ t d | j � � � n | d k r� t | � r� | \ } } n | d k r� | j | � } n | d k r� | j | � } n | j � \ } } | d k r� | } n | d k r� | } n | | k r(t j d d d | | f � n t j
| | d t �\ } } | j j
| | � \ } } | | f | j _ | d k r�t | � | _ n | r/| j j d | � x� | j j | � D]k } | | k r�| j | j j d t d
| �| j | j k r(| j j d k r(| j j j � q(q�q�Wn | | f S( s�
Call signature::
set_ylim(self, *args, **kwargs):
Set the data limits for the yaxis
Examples::
set_ylim((bottom, top))
set_ylim(bottom, top)
set_ylim(bottom=1) # top unchanged
set_ylim(top=1) # bottom unchanged
Keyword arguments:
*bottom*: scalar
The bottom ylim; the previous name, *ymin*, may still be used
*top*: scalar
The top ylim; the previous name, *ymax*, may still be used
*emit*: [ *True* | *False* ]
Notify observers of limit change
*auto*: [ *True* | *False* | *None* ]
Turn *y* autoscaling on (*True*), off (*False*; default),
or leave unchanged (*None*)
Note, the *bottom* (formerly *ymin*) value may be greater than
the *top* (formerly *ymax*).
For example, suppose *y* is depth in the ocean.
Then one might use::
set_ylim(5000, 0)
so 5000 m depth is at the bottom of the plot and the
surface, 0 m, is at the top.
Returns the current ylimits as a length 2 tuple
ACCEPTS: length 2 sequence of floats
Rw Rx s unrecognized kwargs: %ss0 Attempting to set identical bottom==top results
s6 in singular transformations; automatically expanding.
s bottom=%s, top=%sR t ylim_changedR R� N( RC R Re R R� RZ R9 R( R) R� R R
RB R� R� R! R R< R� R� R� R R: R� R� R� ( R2 R� R� R R� Rh t
old_bottomt old_topR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR: �
sF ,
c C s
| j j � S( N( RB R4 ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� �
s s! Return the yaxis scale string: %sc K s1 | j j | | � | j d t � | j � d S( s�
Call signature::
set_yscale(value)
Set the scaling of the y-axis: %(scale)s
ACCEPTS: [%(scale)s]
Different kwargs are accepted, depending on the scale:
%(scale_docs)s
R N( RB R3 R� R
R� ( R2 R� RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� �
s c C s | j j d | � S( s) Return the y ticks as a list of locationsR, ( RB R� ( R2 R, ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_yticks�
s c C s | j j | d | �S( s�
Set the y ticks with list of *ticks*
ACCEPTS: sequence of floats
Keyword arguments:
*minor*: [ *False* | *True* ]
Sets the minor ticks if *True*
R, ( RB R� ( R2 R� R, ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
set_yticks�
s c C s t j d | j j � � S( sl
Get the major y tick labels as a list of
:class:`~matplotlib.text.Text` instances.
s Text yticklabel( R) R� RB R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_ymajorticklabels s c C s t j d | j j � � S( sl
Get the minor y tick labels as a list of
:class:`~matplotlib.text.Text` instances.
s Text yticklabel( R) R� RB R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yminorticklabels s c C s t j d | j j d | � � S( se
Get the y tick labels as a list of :class:`~matplotlib.text.Text`
instances
s Text yticklabelR, ( R) R� RB R� ( R2 R, ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_yticklabels s c K s | j j | | d | | �S( s�
Call signature::
set_yticklabels(labels, fontdict=None, minor=False, **kwargs)
Set the y tick labels with list of strings *labels*. Return a list of
:class:`~matplotlib.text.Text` instances.
*kwargs* set :class:`~matplotlib.text.Text` properties for the labels.
Valid properties are
%(Text)s
ACCEPTS: sequence of strings
R, ( RB R� ( R2 R� R� R, RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_yticklabels s c C s | j j | � d S( s�
Sets up x-axis ticks and labels that treat the x data as dates.
*tz* is a timezone string or :class:`tzinfo` instance.
Defaults to rc value.
N( RA t axis_date( R2 t tz( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
xaxis_date. s c C s | j j | � d S( s�
Sets up y-axis ticks and labels that treat the y data as dates.
*tz* is a timezone string or :class:`tzinfo` instance.
Defaults to rc value.
N( RB R� ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
yaxis_date9 s c C sH y | j | � SWn0 t k
rC | j j � j } | | � } | SXd S( s�
Return *x* string formatted. This function will use the attribute
self.fmt_xdata if it is callable, else will fall back on the xaxis
major formatter
N( R� RN RA R/ t format_data_short( R2 R` RT RR ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt format_xdataB s
c C sH y | j | � SWn0 t k
rC | j j � j } | | � } | SXd S( s�
Return y string formatted. This function will use the
:attr:`fmt_ydata` attribute if it is callable, else will fall
back on the yaxis major formatter
N( R� RN RB R/ R� ( R2 Ra RT RR ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt format_ydataN s
c C sV | d k r d } n | j | � } | d k r9 d } n | j | � } d | | f S( s4 Return a format string formatting the *x*, *y* coords ???s x=%s y=%sN( R R� R� ( R2 R` Ra t xst ys( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt format_coordZ s c C s t S( sX
Return *True* if this axes supports the zoom box button functionality.
( R ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt can_zoomh s c C s t S( sX
Return *True* if this axes supports any pan/zoom button functionality.
( R ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt can_pann s c C s | j S( sF
Get whether the axes responds to navigation commands
( t _navigate( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_navigatet s c C s
| | _ d S( su
Set whether the axes responds to navigation toolbar commands
ACCEPTS: [ *True* | *False* ]
N( R� ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� z s c C s | j S( sR
Get the navigation toolbar button status: 'PAN', 'ZOOM', or None
( t _navigate_mode( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_navigate_mode� s c C s
| | _ d S( s
Set the navigation toolbar button status;
.. warning::
this is not a user-API function.
N( R� ( R2 Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s c
C sa t j d | j j � d | j j � d | j j � j � d | j j � d | d | � | _ d S( s2
Called when a pan operation has started.
*x*, *y* are the mouse coordinates in display coords.
button is the mouse button number:
* 1: LEFT
* 2: MIDDLE
* 3: RIGHT
.. note::
Intended to be overridden by new projection types.
t limt transt
trans_inverseR� R` Ra N( R) t BunchR� R� R� t invertedR� t
_pan_start( R2 R` Ra t button( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt start_pan� s c C s
| ` d S( s�
Called when a pan operation completes (when the mouse button
is up.)
.. note::
Intended to be overridden by new projection types.
N( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt end_pan� s
c C s� d � } | j } | | j } | | j } | d k rH | d k rH d S| d k r� | | | | � \ } } | j j | | � j | j � } n| d k r�y� | t | j j � } | t | j j � } | | | | � \ } } | j
� d k rd | | } | } n t j d | | f � }
t j
| j | j g � } | j j | j � } | |
| | }
t j |
� j | j � } Wq�t k
r�t j d � d SXn | j | j � | j | j � d S(
s`
Called when the mouse moves during a pan operation.
*button* is the mouse button number:
* 1: LEFT
* 2: MIDDLE
* 3: RIGHT
*key* is a "shift" key
*x*, *y* are the mouse coordinates in display coords.
.. note::
Intended to be overridden by new projection types.
c S s | d k r6 t | � t | � k r- | } q| } n� | d k rK d } n� | d k r` d } n� | d k rd t | � t | � k r� d } qd t | � t | � k r� d } qt | � t | � k r� | t | � t | � } q| t | � t | � } n | | f S( Nt controlR` i Ra t shifti ( R� ( RQ t dxt dy( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
format_deltas� s" i Ni i R� g �?g $@s Overflow while panning( R� R` Ra R� t
translatedt transformedR� Rw R� R� Rf R[ t powert arrayR� R� R� R� t
OverflowErrorR( R) R. R R: R! ( R2 R� RQ R` Ra R� R� R� R� t resultt alphat startt oldpointst newpoints( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt drag_pan� s:
c C s | j S( s�
Return the cursor propertiess as a (*linewidth*, *color*)
tuple, where *linewidth* is a float and *color* is an RGBA
tuple
( t _cursorProps( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_cursor_props� s c G sw t | � d k r% | d \ } } n- t | � d k rF | \ } } n t d � � t j j | � } | | f | _ d S( s�
Set the cursor property as::
ax.set_cursor_props(linewidth, color)
or::
ax.set_cursor_props((linewidth, color))
ACCEPTS: a (*float*, *color*) tuple
i i i s' args must be a (linewidth, color) tupleN( Rt R R R t to_rgbaR� ( R2 RH t lwR% ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s c C s t d � � d S( s�
Register observers to be notified when certain events occur. Register
with callback functions with the following signatures. The function
has the following signature::
func(ax) # where ax is the instance making the callback.
The following events can be connected to:
'xlim_changed','ylim_changed'
The connection id is is returned - you can use this with
disconnect to disconnect from the axes event
s3 use the callbacks CallbackRegistry instance insteadN( R* ( R2 R RT ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s c C s t d � � d S( s disconnect from the Axes event.s3 use the callbacks CallbackRegistry instance insteadN( R* ( R2 t cid( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
disconnect. s c C s� g } | j | j � | j | j � | j | j � | j | j � | j | j � | j | j � | j | j � | j | j � | j
d k r� | j | j
� n | j | j � | j | j
� | j | j � | j | j j � � | S( s return a list of child artistsN( R{ RA RB R- R� R� R� R� RC R� RE R R� RL RN R� R/ ( R2 t children( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_children3 s c C s/ t | j � r | j | | � S| j j | � S( si
Test whether the mouse event occured in the axes.
Returns *True* / *False*, {}
( t callablet _containsRN R ( R2 R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR F s c C s | j j | d d �S( s�
Returns *True* if the point (tuple of x,y) is inside the axes
(the area defined by the its patch). A pixel coordinate is
required.
t radiusg �?( RN t contains_point( R2 t point( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� P s c G s< t | � d k r! t d � � n t j j | | d � d S( s�
Call signature::
pick(mouseevent)
each child artist will fire a pick event if mouseevent is over
the artist and the artist has picker set
i sC New pick API implemented -- see API_CHANGES in the src distributioni N( Rt R* R� R� t pick( R2 RH ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� Y s c sH | d k r$ | j | | f � � n | | f � d � } d � � � � f d � } | j | j | j } t | � r� t t | � } nt t | � r� t g | D] } | d f ^ q� � } g | D] }
|
| k r� |
^ q� } n | d k r� n t
d � � t | � s
d Sg | D] }
| |
� |
f ^ q} | j � | d d S( s3
Return the artist under point that is closest to the *x*, *y*.
If *trans* is *None*, *x*, and *y* are in window coords,
(0,0 = lower left). Otherwise, *trans* is a
:class:`~matplotlib.transforms.Transform` that specifies the
coordinate system of *x*, *y*.
The selection of artists from amongst which the pick function
finds an artist can be narrowed using the optional keyword
argument *among*. If provided, this should be either a sequence
of permitted artists or a function taking an artist as its
argument and returning a true value if and only if that artist
can be selected.
Note this algorithm calculates distance to the vertices of the
polygon, so if you want to pick a patch, click on the edge!
c S s9 | \ } } | \ } } t j | | d | | d � S( s& return the distance between two pointsi ( Rs t sqrt( t p1t p2RX R^ t x2t y2( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt dist_points s c S s3 | \ } } t t j | | d | | d � � S( s@ *x* and *y* are arrays; return the distance to the closest pointi ( t minR[ R� ( R� R` Ra RX R^ ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt dist_x_y� s c
s= t | t � r | j � } | j \ } } } } | | f | | | f | | | | f | | | f f } t | � \ } } n� t | t � r� | j � } | j � j | � }
t |
� \ } } nW t | t j
� r| j d t � } | j
d t � } | j � j | | � \ } } n � � t j | � t j | � � S( Nt orig( R� RK R� R� Ru t PatchR� R R� R Rg t get_xdataR
t get_ydatat numerix_x_yR[ R� (
R R� R� Rc R� R� t vertst xtt ytR� t tvertsR R ( R� t xywin( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt dist� s : !i s" among must be callable or iterablei N(
R t transform_pointR� R� R� R� t filtert testR� Ru R Rt R3 ( R2 R` Ra R� t amongR� R� RC R} t amongdR t ds( ( R� R� s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt __pickg s( %( %
c C s
| j j � S( s,
Get the title text string.
( RL t get_text( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_title� s c K su i t d d 6d d 6d d 6} | j j | � | j j | � | d k r^ | j j | � n | j j | � | j S( sD
Call signature::
set_title(label, fontdict=None, **kwargs):
Set the title for the axes.
kwargs are Text properties:
%(Text)s
ACCEPTS: str
.. seealso::
:meth:`text`
for information on how override and the optional args work
s axes.titlesizet fontsizeR% R$ R� R& N( R RL t set_textt updateR ( R2 R� R� RI t default( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_title� s
c C s | j j � } | j � S( s-
Get the xlabel text string.
( RA R� R� ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_xlabel� s c K s1 | d k r | | j _ n | j j | | | � S( s�
Call signature::
set_xlabel(xlabel, fontdict=None, labelpad=None, **kwargs)
Set the label for the xaxis.
*labelpad* is the spacing in points between the label and the x-axis
Valid kwargs are :class:`~matplotlib.text.Text` properties:
%(Text)s
ACCEPTS: str
.. seealso::
:meth:`text`
for information on how override and the optional args work
N( R RA t labelpadt set_label_text( R2 t xlabelR� R� RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
set_xlabel� s c C s | j j � } | j � S( s-
Get the ylabel text string.
( RB R� R� ( R2 R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
get_ylabel� s c K s1 | d k r | | j _ n | j j | | | � S( s�
Call signature::
set_ylabel(ylabel, fontdict=None, labelpad=None, **kwargs)
Set the label for the yaxis
*labelpad* is the spacing in points between the label and the y-axis
Valid kwargs are :class:`~matplotlib.text.Text` properties:
%(Text)s
ACCEPTS: str
.. seealso::
:meth:`text`
for information on how override and the optional args work
N( R RB R� R� ( R2 t ylabelR� R� RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
set_ylabel� s c s� i d d 6d d 6� j d 6} | rE t j d | d | d | � } n t j d | d | d | � } � j | � | j | � | d k r� | j | � n | j | � � j j | � � f d � | _ d
| k r� | j
� j � n | S( s
Add text to the axes.
Call signature::
text(x, y, s, fontdict=None, **kwargs)
Add text in string *s* to axis at location *x*, *y*, data
coordinates.
Keyword arguments:
*fontdict*:
A dictionary to override the default text properties.
If *fontdict* is *None*, the defaults are determined by your rc
parameters.
*withdash*: [ *False* | *True* ]
Creates a :class:`~matplotlib.text.TextWithDash` instance
instead of a :class:`~matplotlib.text.Text` instance.
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 (eg. to
set a background color) by using the keyword *bbox*. *bbox* is
a dictionary of :class:`matplotlib.patches.Rectangle`
properties. For example::
text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))
Valid kwargs are :class:`~matplotlib.text.Text` properties:
%(Text)s
R% R$ R� R& R� R` Ra R" c s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� [
s t clip_onN( R� RJ t TextWithDashRK R R� R R� R{ R� RM R� ( R2 R` Ra R R� t withdashRI R� RN ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR"
s& 2
c sz t j | | � } | j t j � � � j | � | j d � rT | j � j � n � j j
| � � f d � | _ | S( se
Create an annotation: a piece of text referring to a data
point.
Call signature::
annotate(s, xy, xytext=None, xycoords='data',
textcoords='data', arrowprops=None, **kwargs)
Keyword arguments:
%(Annotation)s
.. plot:: mpl_examples/pylab_examples/annotation_demo2.py
R c s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� x
s ( RJ t
AnnotationR R� R� R t has_keyRT RN R� R{ R� ( R2 RH RI R ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt annotateb
s
i i c K s� d | k r t d d � � n | j � \ } } | j d | d | � | j | � } | | k pk | | k } t j | j | j � } t j | | g | | g d | | �}
| j
|
� | j d t d | � |
S( sY
Add a horizontal line across the axis.
Call signature::
axhline(y=0, xmin=0, xmax=1, **kwargs)
Draw a horizontal line at *y* from *xmin* to *xmax*. With the
default values of *xmin* = 0 and *xmax* = 1, this line will
always span the horizontal extent of the axes, regardless of
the xlim settings, even if you change them, eg. 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.
Return value is the :class:`~matplotlib.lines.Line2D`
instance. kwargs are the same as kwargs to plot, and can be
used to control the line properties. Eg.,
* 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 the middle half of
the xrange::
>>> axhline(y=.5, xmin=0.25, xmax=0.75)
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
with the exception of 'transform':
%(Line2D)s
.. seealso::
:meth:`axhspan`
for example plot and source code
R� s& 'transform' is not allowed as a kwarg;s$ axhline generates its own transform.R RI R R (
R Rr R RZ R� R� R� R� R Rg R� R� R
( R2 Ra Ru Rv RI Rw Rx t yyR R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt axhline}
s -
'
c K s� d | k r t d d � � n | j � \ } } | j d | d | � | j | � } | | k pk | | k } t j | j | j � } t j | | g | | g d | | �}
| j
|
� | j d | d t � |
S( sQ
Add a vertical line across the axes.
Call signature::
axvline(x=0, ymin=0, ymax=1, **kwargs)
Draw a vertical line at *x* from *ymin* to *ymax*. With the
default values of *ymin* = 0 and *ymax* = 1, this line will
always span the vertical extent of the axes, regardless of the
ylim settings, even if you change them, eg. 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.
Return value is the :class:`~matplotlib.lines.Line2D`
instance. kwargs are the same as kwargs to plot, and can be
used to control the line properties. Eg.,
* 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 the middle half of
the yrange::
>>> axvline(x=.5, ymin=0.25, ymax=0.75)
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
with the exception of 'transform':
%(Line2D)s
.. seealso::
:meth:`axhspan`
for example plot and source code
R� s& 'transform' is not allowed as a kwarg;s$ axvline generates its own transform.R RI R R (
R Rq R RY R� R� R� R� R Rg R� R� R
( R2 R` Rw Rx RI Ru Rv t xxR R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt axvline�
s -
'
c K s� t j | j | j � } | j | | g | | g d | �| j | | g � \ } } | j | | g � \ } } | | f | | f | | f | | f f } t j | | � } | j | � | j
| � | j d t � | S( se
Add a horizontal span (rectangle) across the axis.
Call signature::
axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs)
*y* coords are in data units and *x* coords are in axes (relative
0-1) units.
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, eg. 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.
Return value is a :class:`matplotlib.patches.Polygon`
instance.
Examples:
* draw a gray rectangle from *y* = 0.25-0.75 that spans the
horizontal extent of the axes::
>>> axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5)
Valid kwargs are :class:`~matplotlib.patches.Polygon` properties:
%(Polygon)s
**Example:**
.. plot:: mpl_examples/pylab_examples/axhspan_demo.py
RI R (
R� R� R� R� R RY RZ Ro Rp R R� R� R
( R2 Rw Rx Ru Rv RI R� R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt axhspan�
s '"*
c K s� t j | j | j � } | j | | g | | g d | �| j | | g � \ } } | j | | g � \ } } | | f | | f | | f | | f g } t j | | � } | j | � | j
| � | j d t � | S( sy
Add a vertical span (rectangle) across the axes.
Call signature::
axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs)
*x* coords are in data units and *y* coords are in axes (relative
0-1) units.
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, eg. 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 *y* location is in data coordinates.
Return value is the :class:`matplotlib.patches.Polygon`
instance.
Examples:
* draw a vertical green translucent rectangle from x=1.25 to 1.55 that
spans the yrange of the axes::
>>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)
Valid kwargs are :class:`~matplotlib.patches.Polygon`
properties:
%(Polygon)s
.. seealso::
:meth:`axhspan`
for example plot and source code
RI R (
R� R� R� R� R RY RZ Ro Rp R R� R� R
( R2 Ru Rv Rw Rx RI R� R� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt axvspan5 s '"*
R} t solidc K s� | j d � d k r$ t d � � n | j | | g | d | �| j | � } | j | � } | j | � } t | � s� | g } n t | � s� | g } n t | � s� | g } n t j | � } t j | � } t j | � } t | � d k r t j
| | j � } n t | � d k r6t j
| | j � } n t | � t | � k r]t d � � n t | � t | � k r�t d � � n g t
| | | � D]' \ } } }
| |
f | |
f f ^ q�} t j | d | d | d | �} | j | � | j | � t | � d
k r�t | j � | j � � }
t | j � | j � � } | j � } | j � } |
| f | | f f } | j | � | j � n | S( s�
Plot horizontal lines.
call signature::
hlines(y, xmin, xmax, colors='k', linestyles='solid', **kwargs)
Plot horizontal lines at each *y* from *xmin* to *xmax*.
Returns the :class:`~matplotlib.collections.LineCollection`
that was added.
Required arguments:
*y*:
a 1-D numpy array or iterable.
*xmin* and *xmax*:
can be scalars or ``len(x)`` numpy arrays. If they are
scalars, then the respective values are constant, else the
widths of the lines are determined by *xmin* and *xmax*.
Optional keyword arguments:
*colors*:
a line collections color argument, either a single color
or a ``len(y)`` list of colors
*linestyles*:
[ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
**Example:**
.. plot:: mpl_examples/pylab_examples/hline_demo.py
R s^ hlines now uses a collections.LineCollection and not a list of Line2D to draw; see API_CHANGESRI i s& xmin and y are unequal sized sequencess& xmax and y are unequal sized sequencesR t
linestylesR� i N( Rx R R* R RZ RY R� R[ R� Rt t resizeR] R Ru t mcollt LineCollectionR� R� R� Rz R� R� ( R2 Ra Ru Rv R R R� RI t thisxmint thisxmaxt thisyR� t collt minxt maxxt minyt maxyt corners( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt hlinesn sL & =
c K s� | j d � d
k r$ t d � � n | j d | d | | g d | � | j | � } | j | � } | j | � } t | � s� | g } n t | � s� | g } n t | � s� | g } n t j | � } t j | � } t j | � } t | � d k rt j
| | j � } n t | � d k r<t j
| | j � } n t | � t | � k rct d � � n t | � t | � k r�t d � � n t j
| | g � j } g t | | � D]* \ } \ }
} | |
f | | f f ^ q�} t j | d | d
| d | �}
| j |
� |
j | � t | � d k r�t | � } t | � } t t | � t | � � } t t | � t | � � } | | f | | f f } | j | � | j � n |
S( s
Plot vertical lines.
Call signature::
vlines(x, ymin, ymax, color='k', linestyles='solid')
Plot vertical lines at each *x* from *ymin* to *ymax*. *ymin*
or *ymax* can be scalars or len(*x*) numpy arrays. If they are
scalars, then the respective values are constant, else the
heights of the lines are determined by *ymin* and *ymax*.
*colors* :
A line collection's color args, either a single color
or a ``len(x)`` list of colors
*linestyles* : [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
Returns the :class:`matplotlib.collections.LineCollection`
that was added.
kwargs are :class:`~matplotlib.collections.LineCollection` properties:
%(LineCollection)s
R s^ vlines now uses a collections.LineCollection and not a list of Line2D to draw; see API_CHANGESR R RI i s& ymin and x are unequal sized sequencess& ymax and x are unequal sized sequencesR R R� i N( Rx R R* R RY RZ R� R[ R� Rt R R] R R� t TRu R R R� R� R� Rz R� R� ( R2 R` Rw Rx R R R� RI t Yt thisxt thisymint thisymaxR� R R R R R R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt vlines� sN " =
c O s� | j d t � } | j d t � } | j s: | j � n g } x4 | j | | � D] } | j | � | j | � qS W| j d | d | � | S( s
Plot lines and/or markers to the
:class:`~matplotlib.axes.Axes`. *args* is a variable length
argument, allowing for multiple *x*, *y* pairs with an
optional format string. For example, each of the following is
legal::
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
If *x* and/or *y* is 2-dimensional, then the corresponding columns
will be plotted.
An arbitrary number of *x*, *y*, *fmt* groups can be
specified, as in::
a.plot(x1, y1, 'g^', x2, y2, 'g-')
Return value is a list of lines that were added.
By default, each line is assigned a different color specified by a
'color cycle'. To change this behavior, you can edit the
axes.color_cycle rcParam. Alternatively, you can use
:meth:`~matplotlib.axes.Axes.set_default_color_cycle`.
The following format string characters are accepted to control
the line style or marker:
================ ===============================
character description
================ ===============================
``'-'`` solid line style
``'--'`` dashed line style
``'-.'`` dash-dot line style
``':'`` dotted line style
``'.'`` 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
================ ===============================
The following color abbreviations are supported:
========== ========
character color
========== ========
'b' blue
'g' green
'r' red
'c' cyan
'm' magenta
'y' yellow
'k' black
'w' white
========== ========
In addition, you can specify colors in many weird and
wonderful ways, including full names (``'green'``), hex
strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or
grayscale intensities as a string (``'0.8'``). Of these, the
string specifications can be used in place of a ``fmt`` group,
but the tuple forms can be used only as ``kwargs``.
Line styles and colors are combined in a single format string, as in
``'bo'`` for blue circles.
The *kwargs* can be used to set line properties (any property that has
a ``set_*`` method). You can use this to set a line label (for auto
legends), linewidth, anitialising, marker face color, etc. Here is an
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')
axis([0, 4, 0, 10])
legend()
If you make multiple lines with one plot command, the kwargs
apply to all those lines, e.g.::
plot(x1, y1, x2, y2, antialised=False)
Neither line will be antialiased.
You do not need to use format strings, which are just
abbreviations. All of the line properties can be controlled
by keyword arguments. For example, you can set the color,
marker, linestyle, and markercolor with::
plot(x, y, color='green', linestyle='dashed', marker='o',
markerfacecolor='blue', markersize=12).
See :class:`~matplotlib.lines.Line2D` for details.
The kwargs are :class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
kwargs *scalex* and *scaley*, if defined, are passed on to
:meth:`~matplotlib.axes.Axes.autoscale_view` to determine
whether the *x* and *y* axes are autoscaled; the default is
*True*.
R R ( RC R R� R� R@ R� R{ R� ( R2 RH RI R R R� RP ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR. s }
t boc K sh | j s | j � n | j | | | | � } | rD | j | � n | rZ | j | � n | j � | S( sh
Plot with data with dates.
Call signature::
plot_date(x, y, fmt='bo', tz=None, xdate=True, ydate=False, **kwargs)
Similar to the :func:`~matplotlib.pyplot.plot` command, except
the *x* or *y* (or both) data is considered to be dates, and the
axis is labeled accordingly.
*x* and/or *y* can be a sequence of dates represented as float
days since 0001-01-01 UTC.
Keyword arguments:
*fmt*: string
The plot format string.
*tz*: [ *None* | timezone string | :class:`tzinfo` instance]
The time zone to use in labeling dates. If *None*, defaults to rc
value.
*xdate*: [ *True* | *False* ]
If *True*, the *x*-axis will be labeled with dates.
*ydate*: [ *False* | *True* ]
If *True*, the *y*-axis will be labeled with dates.
Note if you are using custom date tickers and formatters, it
may be necessary to set the formatters/locators after the call
to :meth:`plot_date` since :meth:`plot_date` will set the
default tick locator to
:class:`matplotlib.dates.AutoDateLocator` (if the tick
locator is not already set to a
:class:`matplotlib.dates.DateLocator` instance) and the
default tick formatter to
:class:`matplotlib.dates.AutoDateFormatter` (if the tick
formatter is not already set to a
:class:`matplotlib.dates.DateFormatter` instance).
Valid kwargs are :class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
.. seealso::
:mod:`~matplotlib.dates` for helper functions
:func:`~matplotlib.dates.date2num`,
:func:`~matplotlib.dates.num2date` and
:func:`~matplotlib.dates.drange` for help on creating the required
floating point dates.
( R� R� R. R� R� R� ( R2 R` Ra R R� t xdatet ydateRI RJ ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt plot_date� s :
c O s� | j s | j � n i | j d d � d 6| j d d
� d 6| j d d � d 6} i | j d d � d 6| j d d
� d 6| j d d � d 6} | j d | � | j d | � | j } t | _ | j | | � } | | _ | S( s�
Make a plot with log scaling on both the *x* and *y* axis.
Call signature::
loglog(*args, **kwargs)
:func:`~matplotlib.pyplot.loglog` supports all the keyword
arguments of :func:`~matplotlib.pyplot.plot` and
:meth:`matplotlib.axes.Axes.set_xscale` /
:meth:`matplotlib.axes.Axes.set_yscale`.
Notable keyword arguments:
*basex*/*basey*: scalar > 1
Base of the *x*/*y* logarithm
*subsx*/*subsy*: [ *None* | sequence ]
The location of the minor *x*/*y* ticks; *None* defaults
to autosubs, which depend on the number of decades in the
plot; see :meth:`matplotlib.axes.Axes.set_xscale` /
:meth:`matplotlib.axes.Axes.set_yscale` for details
*nonposx*/*nonposy*: ['mask' | 'clip' ]
Non-positive values in *x* or *y* can be masked as
invalid, or clipped to a very small positive number
The remaining valid kwargs are
:class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
**Example:**
.. plot:: mpl_examples/pylab_examples/log_demo.py
t basexi
t subsxt nonposxt maskt baseyt subsyt nonposyR~ N( R� R� RC R R� R� R R. ( R2 RH RI R� R� Rc R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt loglog� s '
c O s� | j s | j � n i | j d d � d 6| j d d � d 6| j d d � d 6} | j d | � | j } t | _ | j | | � } | | _ | S( s�
Make a plot with log scaling on the *x* axis.
Call signature::
semilogx(*args, **kwargs)
:func:`semilogx` supports all the keyword arguments of
:func:`~matplotlib.pyplot.plot` and
:meth:`matplotlib.axes.Axes.set_xscale`.
Notable keyword arguments:
*basex*: scalar > 1
Base of the *x* logarithm
*subsx*: [ *None* | sequence ]
The location of the minor xticks; *None* defaults to
autosubs, which depend on the number of decades in the
plot; see :meth:`~matplotlib.axes.Axes.set_xscale` for
details.
*nonposx*: [ 'mask' | 'clip' ]
Non-positive values in *x* can be masked as
invalid, or clipped to a very small positive number
The remaining valid kwargs are
:class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
.. seealso::
:meth:`loglog`
For example code and figure
R) i
R* R+ R, R~ N( R� R� RC R R� R R. ( R2 RH RI t dRc R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt semilogx' s &
c O s� | j s | j � n i | j d d � d 6| j d d � d 6| j d d � d 6} | j d | � | j } t | _ | j | | � } | | _ | S( s�
Make a plot with log scaling on the *y* axis.
call signature::
semilogy(*args, **kwargs)
:func:`semilogy` supports all the keyword arguments of
:func:`~matplotlib.pylab.plot` and
:meth:`matplotlib.axes.Axes.set_yscale`.
Notable keyword arguments:
*basey*: scalar > 1
Base of the *y* logarithm
*subsy*: [ *None* | sequence ]
The location of the minor yticks; *None* defaults to
autosubs, which depend on the number of decades in the
plot; see :meth:`~matplotlib.axes.Axes.set_yscale` for
details.
*nonposy*: [ 'mask' | 'clip' ]
Non-positive values in *y* can be masked as
invalid, or clipped to a very small positive number
The remaining valid kwargs are
:class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
.. seealso::
:meth:`loglog`
For example code and figure
R- i
R. R/ R, R~ N( R� R� RC R R� R R. ( R2 RH RI R1 Rc R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt semilogyZ s &
c K s | j | | | � S( s�
Plot the autocorrelation of *x*.
Call signature::
acorr(x, normed=True, detrend=mlab.detrend_none, usevlines=True,
maxlags=10, **kwargs)
If *normed* = *True*, normalize the data by the autocorrelation at
0-th lag. *x* is detrended by the *detrend* callable (default no
normalization).
Data are plotted as ``plot(lags, c, **kwargs)``
Return value is a tuple (*lags*, *c*, *line*) where:
- *lags* are a length 2*maxlags+1 lag vector
- *c* is the 2*maxlags+1 auto correlation vector
- *line* is a :class:`~matplotlib.lines.Line2D` instance
returned by :meth:`plot`
The default *linestyle* is None and the default *marker* is
``'o'``, though these can be overridden with keyword args.
The cross correlation is performed with
:func:`numpy.correlate` with *mode* = 2.
If *usevlines* is *True*, :meth:`~matplotlib.axes.Axes.vlines`
rather than :meth:`~matplotlib.axes.Axes.plot` is used to draw
vertical lines from the origin to the acorr. Otherwise, the
plot style is determined by the kwargs, which are
:class:`~matplotlib.lines.Line2D` properties.
*maxlags* is a positive integer detailing the number of lags
to show. The default value of *None* will return all
``(2*len(x)-1)`` lags.
The return value is a tuple (*lags*, *c*, *linecol*, *b*)
where
- *linecol* is the
:class:`~matplotlib.collections.LineCollection`
- *b* is the *x*-axis.
.. seealso::
:meth:`~matplotlib.axes.Axes.plot` or
:meth:`~matplotlib.axes.Axes.vlines`
For documentation on valid kwargs.
**Example:**
:func:`~matplotlib.pyplot.xcorr` is top graph, and
:func:`~matplotlib.pyplot.acorr` is bottom graph.
.. plot:: mpl_examples/pylab_examples/xcorr_demo.py
( t xcorr( R2 R` RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt acorr� s =i
c
K s� t | � } | t | � k r- t d � � n | t j | � � } | t j | � � } t j | | d d �} | r� | t j t j | | � t j | | � � } n | d k r� | d } n | | k s� | d k r� t d | � � n t j | | d � }
| | d | | | !} | rN| j |
d g | | � } | j
| � } n> | j d d � | j d d
� | j |
| | � \ } d } |
| | | f S( s�
Plot the cross correlation between *x* and *y*.
Call signature::
xcorr(self, x, y, normed=True, detrend=mlab.detrend_none,
usevlines=True, maxlags=10, **kwargs)
If *normed* = *True*, normalize the data by the cross
correlation at 0-th lag. *x* and y are detrended by the
*detrend* callable (default no normalization). *x* and *y*
must be equal length.
Data are plotted as ``plot(lags, c, **kwargs)``
Return value is a tuple (*lags*, *c*, *line*) where:
- *lags* are a length ``2*maxlags+1`` lag vector
- *c* is the ``2*maxlags+1`` auto correlation vector
- *line* is a :class:`~matplotlib.lines.Line2D` instance
returned by :func:`~matplotlib.pyplot.plot`.
The default *linestyle* is *None* and the default *marker* is
'o', though these can be overridden with keyword args. The
cross correlation is performed with :func:`numpy.correlate`
with *mode* = 2.
If *usevlines* is *True*:
:func:`~matplotlib.pyplot.vlines`
rather than :func:`~matplotlib.pyplot.plot` is used to draw
vertical lines from the origin to the xcorr. Otherwise the
plotstyle is determined by the kwargs, which are
:class:`~matplotlib.lines.Line2D` properties.
The return value is a tuple (*lags*, *c*, *linecol*, *b*)
where *linecol* is the
:class:`matplotlib.collections.LineCollection` instance and
*b* is the *x*-axis.
*maxlags* is a positive integer detailing the number of lags to show.
The default value of *None* will return all ``(2*len(x)-1)`` lags.
**Example:**
:func:`~matplotlib.pyplot.xcorr` is top graph, and
:func:`~matplotlib.pyplot.acorr` is bottom graph.
.. plot:: mpl_examples/pylab_examples/xcorr_demo.py
s x and y must be equal lengtht modei i s. maglags must be None or strictly positive < %di R" t oR! R N(
Rt R R[ R� t correlateR� t dotR Rv R$ R t
setdefaultR. (
R2 R` Ra t normedt detrendt usevlinest maxlagsRI t NxR% t lagsR Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR4 � s. 8 2
c C s� | j | j | j | j } t j j � } | d k rU | j � } | j | � n g } xK | D]C } | j
� d k r� qb n t j j | | � rb | j | � qb qb W| S( s6 return artists that will be used as handles for legendt
_nolegend_N(
R� R� R� RF t mlegendt Legendt get_default_handler_mapR R5 R� R� t get_legend_handlerR{ ( R2 t legend_handler_mapt handles_originalt handler_mapt handlesR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _get_legend_handles% s
c C so g } g } xV | j | � D]E } | j � } | r | j d � r | j | � | j | � q q W| | f S( s�
Return handles and labels for legend
``ax.legend()`` is equivalent to ::
h, l = ax.get_legend_handles_labels()
ax.legend(h, l)
R� ( RJ R� t
startswithR{ ( R2 RF RI R� t handleR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_legend_handles_labels; s
c O s~ t | � d k rJ | j � \ } } t | � d k r\t j d � d Snt | � d k r� | d } g t | j � | � D] \ } } | ^ q| } n� t | � d k r"t | d � s� t | d t � r| \ } } g t | j � | � D] \ } } | ^ q� } | | d <q\| \ } } n: t | � d k rP| \ } } } | | d <n t
d � � t j | | | | � | _
| j
S( s�
Place a legend on the current axes.
Call signature::
legend(*args, **kwargs)
Places legend at location *loc*. Labels are a sequence of
strings and *loc* can be a string or an integer specifying the
legend location.
To make a legend with existing lines::
legend()
:meth:`legend` by itself will try and build a legend using the label
property of the lines/patches/collections. You can set the label of
a line by doing::
plot(x, y, label='my data')
or::
line.set_label('my data').
If label is set to '_nolegend_', the item will not be shown in
legend.
To automatically generate the legend from labels::
legend( ('label1', 'label2', 'label3') )
To make a legend for a list of lines and labels::
legend( (line1, line2, line3), ('label1', 'label2', 'label3') )
To make a legend at a given location, using a location argument::
legend( ('label1', 'label2', 'label3'), loc='upper left')
or::
legend( (line1, line2, line3), ('label1', 'label2', 'label3'), loc=2)
The location codes are
=============== =============
Location String Location Code
=============== =============
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
=============== =============
Users can specify any arbitrary location for the legend using the
*bbox_to_anchor* keyword argument. bbox_to_anchor can be an instance
of BboxBase(or its derivatives) or a tuple of 2 or 4 floats.
For example,
loc = 'upper right', bbox_to_anchor = (0.5, 0.5)
will place the legend so that the upper right corner of the legend at
the center of the axes.
The legend location can be specified in other coordinate, by using the
*bbox_transform* keyword.
The loc itslef can be a 2-tuple giving x,y of the lower-left corner of
the legend in axes coords (*bbox_to_anchor* is ignored).
Keyword arguments:
*prop*: [ *None* | FontProperties | dict ]
A :class:`matplotlib.font_manager.FontProperties`
instance. If *prop* is a dictionary, a new instance will be
created with *prop*. If *None*, use rc settings.
*fontsize*: [ size in points | 'xx-small' | 'x-small' |
'small' | 'medium' | 'large' | 'x-large' | 'xx-large' ]
Set the font size. May be either a size string, relative to
the default font size, or an absolute font size in points. This
argument is only used if prop is not specified.
*numpoints*: integer
The number of points in the legend for line
*scatterpoints*: integer
The number of points in the legend for scatter plot
*scatteroffsets*: list of floats
a list of yoffsets for scatter symbols in legend
*markerscale*: [ *None* | scalar ]
The relative size of legend markers vs. original. If *None*,
use rc settings.
*frameon*: [ *True* | *False* ]
if *True*, draw a frame around the legend.
The default is set by the rcParam 'legend.frameon'
*fancybox*: [ *None* | *False* | *True* ]
if *True*, draw a frame with a round fancybox. If *None*,
use rc settings
*shadow*: [ *None* | *False* | *True* ]
If *True*, draw a shadow behind legend. If *None*,
use rc settings.
*ncol* : integer
number of columns. default is 1
*mode* : [ "expand" | *None* ]
if mode is "expand", the legend will be horizontally expanded
to fill the axes area (or *bbox_to_anchor*)
*bbox_to_anchor* : an instance of BboxBase or a tuple of 2 or 4 floats
the bbox that the legend will be anchored.
*bbox_transform* : [ an instance of Transform | *None* ]
the transform for the bbox. transAxes if *None*.
*title* : string
the legend title
Padding and spacing between various elements use following
keywords parameters. These values are measure in font-size
units. E.g., a fontsize of 10 points and a handlelength=5
implies a handlelength of 50 points. Values from rcParams
will be used if None.
================ ==================================================================
Keyword Description
================ ==================================================================
borderpad the fractional whitespace inside the legend border
labelspacing the vertical space between the legend entries
handlelength the length of the legend handles
handletextpad the pad between the legend handle and text
borderaxespad the pad between the axes and legend border
columnspacing the spacing between columns
================ ==================================================================
.. Note:: Not all kinds of artist are supported by the legend command.
See LINK (FIXME) for details.
**Example:**
.. plot:: mpl_examples/api/legend_demo.py
.. seealso::
:ref:`plotting-guide-legend`.
i sD No labeled objects found. Use label='...' kwarg on individual plots.i i t loci s Invalid arguments to legendN( Rt RM R( R) R Ru RJ R R� R RN RB RC RE ( R2 RH RI RI R� R� R� RN ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt legendR s, �
"#
c O sQ | j d d � } | d k r- t d � � n d | | d <| j | | | | � S( sl
Make a step plot.
Call signature::
step(x, y, *args, **kwargs)
Additional keyword args to :func:`step` are the same as those
for :func:`~matplotlib.pyplot.plot`.
*x* and *y* must be 1-D sequences, and it is assumed, but not checked,
that *x* is uniformly increasing.
Keyword arguments:
*where*: [ 'pre' | 'post' | 'mid' ]
If 'pre', the interval from x[i] to x[i+1] has level y[i+1]
If 'post', that interval has level y[i]
If 'mid', the jumps in *y* occur half-way between the
*x*-values.
t wheret pret postt mids7 'where' argument to step must be 'pre', 'post' or 'mid's steps-R! ( RQ RR RS ( RC R R. ( R2 R` Ra RH RI RP ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt step s
g�������?c , K s' | j s | j � n | j d d& � } | j d d& � } | j d d& � } | j d d& � } | j d d& � }
| j d t � � } | j d d& � } | j d d � }
| j d | � | j d |
� | j d
d � } | j d d
� } | j d t � } | j d d � } d � } | } | | � } | | � } | | � } | } | | � } | | � } t } t } | d
k r5| j d | d | d | � | r�| j d � n | d& k r�| j � d k r�d g } t
} q�d g } n t | � } t | � d k r| | 9} n t | � d k r | | 9} q n� | d k r�| j d | d | d | � | rs| j d � n | d& k r�| j
� d k r�d g } t
} q�d g } n t | � } t | � d k r�| | 9} n t | � d k r | | 9} q n t d | � � t | � | k r+| | 9} n | d& k rGd& g | } na t t j j | � � } t | � d k r�d d d d g g } n t | � | k r�| | 9} n | d& k r�d& g | } na t t j j | � � } t | � d k rd d d d g g } n t | � | k r%| | 9} n g } | j d& k ry| j | � } | j | � } | d& k ry| j | � } qyn | j d& k r�| j | � } | j | � } |
d& k r�| j |
� }
q�n | d k r�n� | d k rm| d
k r&g t t | � � D] } | | | | d ^ q} q}| d k r}g t t | � � D] } | | | | d ^ qE} q}n t d | � � t | | | | | | | � } x� | D]� \ } } } } } } }! | d k r�| | 7} t | � } n | d k r| | 7} t | � } n t j d | | f d | d | d | d | d |! d d! � }" |" j | � d" |" j � _ | j |" � | j |" � q�W| j }# | j! t
� | d& k s�|
d& k r�| d
k rg t | | � D] \ } } | d# | ^ q�}$ g t | | � D] \ } } | | ^ q�}% nk | d k r�g t | | � D] \ } } | | ^ q2}$ g t | | � D] \ } } | d# | ^ q^}% n d | k r�d! | d <n | j" |$ |% d |
d | d$ d& | �}& n d& }& | j! |# � | rg| j# j$ \ }' }( t% j& g | D] } | d k r�| ^ q�� }' | d& k r?|' t% j' | � }' n t( |' d% d � }' |' |( f | j# _$ n | r�| j# j) \ }) }* t% j& g | D] } | d k r�| ^ q�� }) |
d& k r�|) t% j' |
� }) n t( |) d% d � }) |) |* f | j# _) n | j* � t+ | |& d | �}+ | j, |+ � |+ S(' s�
Make a bar plot.
Call signature::
bar(left, height, width=0.8, bottom=0, **kwargs)
Make a bar plot with rectangles bounded by:
*left*, *left* + *width*, *bottom*, *bottom* + *height*
(left, right, bottom and top edges)
*left*, *height*, *width*, and *bottom* can be either scalars
or sequences
Return value is a list of
:class:`matplotlib.patches.Rectangle` instances.
Required arguments:
======== ===============================================
Argument Description
======== ===============================================
*left* the x coordinates of the left sides of the bars
*height* the heights of the bars
======== ===============================================
Optional keyword arguments:
=============== ==========================================
Keyword Description
=============== ==========================================
*width* the widths of the bars
*bottom* the y coordinates of the bottom edges of
the bars
*color* the colors of the bars
*edgecolor* the colors of the bar edges
*linewidth* width of bar edges; None means use default
linewidth; 0 means don't draw edges.
*xerr* if not None, will be used to generate
errorbars on the bar chart
*yerr* if not None, will be used to generate
errorbars on the bar chart
*ecolor* specifies the color of any errorbar
*capsize* (default 3) determines the length in
points of the error bar caps
*error_kw* dictionary of kwargs to be passed to
errorbar method. *ecolor* and *capsize*
may be specified here rather than as
independent kwargs.
*align* 'edge' (default) | 'center'
*orientation* 'vertical' | 'horizontal'
*log* [False|True] False (default) leaves the
orientation axis as-is; True sets it to
log scale
=============== ==========================================
For vertical bars, *align* = 'edge' aligns bars by their left
edges in left, while *align* = 'center' interprets these
values as the *x* coordinates of the bar centers. For
horizontal bars, *align* = 'edge' aligns bars by their bottom
edges in bottom, while *align* = 'center' interprets these
values as the *y* coordinates of the bar centers.
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
**Example:** A stacked bar chart.
.. plot:: mpl_examples/pylab_examples/bar_stacked.py
R# t edgecolort linewidtht xerrt yerrt error_kwt ecolort capsizei t alignt edget orientationt verticalR~ R� R c S s t | � s | g S| Sd S( N( R� ( R` ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
make_iterable� s R R RI g0��.�++i i t
horizontals invalid orientation: %sR� g @s invalid alignment: %st xyR� R� Rk RA id g �?R g�������?N(- R� R� RC R Ru R: R
R R� R� R Rt R� R R t listR R t
to_rgba_arrayRA RY RB RZ Ry Ru R� Ro R R� R� t _interpolation_stepsR� R{ Rd t errorbarR� R R[ t amint amaxRz R! R� R R� (, R2 R� R� R� R� RI R# RU RV RW RX RY RZ R[ R\ R^ R~ R� R` t _leftt _bottomt adjust_ylimt adjust_xlimt nbarsR� t iRH R� Rc R� R� R% t eR� RM t holdstateR` Ra Rf Ru Rv Rw Rx t
bar_container( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt barB s R
8 ; "
0/ ,3
. .
c K s1 | j d | d | d | d | d d | � } | S( s�
Make a horizontal bar plot.
Call signature::
barh(bottom, width, height=0.8, left=0, **kwargs)
Make a horizontal bar plot with rectangles bounded by:
*left*, *left* + *width*, *bottom*, *bottom* + *height*
(left, right, bottom and top edges)
*bottom*, *width*, *height*, and *left* can be either scalars
or sequences
Return value is a list of
:class:`matplotlib.patches.Rectangle` instances.
Required arguments:
======== ======================================================
Argument Description
======== ======================================================
*bottom* the vertical positions of the bottom edges of the bars
*width* the lengths of the bars
======== ======================================================
Optional keyword arguments:
=============== ==========================================
Keyword Description
=============== ==========================================
*height* the heights (thicknesses) of the bars
*left* the x coordinates of the left edges of the
bars
*color* the colors of the bars
*edgecolor* the colors of the bar edges
*linewidth* width of bar edges; None means use default
linewidth; 0 means don't draw edges.
*xerr* if not None, will be used to generate
errorbars on the bar chart
*yerr* if not None, will be used to generate
errorbars on the bar chart
*ecolor* specifies the color of any errorbar
*capsize* (default 3) determines the length in
points of the error bar caps
*align* 'edge' (default) | 'center'
*log* [False|True] False (default) leaves the
horizontal axis as-is; True sets it to log
scale
=============== ==========================================
Setting *align* = 'edge' aligns bars by their bottom edges in
bottom, while *align* = 'center' interprets these values as
the *y* coordinates of the bar centers.
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
barh as the basis for stacked bar charts, or candlestick
plots.
other optional kwargs:
%(Rectangle)s
R� R� R� R� R^ Ra ( Rr ( R2 R� R� R� R� RI R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt barhZ s E! c K s6 t j | | | � } | j | d t �| j � | S( s�
Plot horizontal bars.
Call signature::
broken_barh(self, xranges, yrange, **kwargs)
A collection of horizontal bars spanning *yrange* with a sequence of
*xranges*.
Required arguments:
========= ==============================
Argument Description
========= ==============================
*xranges* sequence of (*xmin*, *xwidth*)
*yrange* sequence of (*ymin*, *ywidth*)
========= ==============================
kwargs are
:class:`matplotlib.collections.BrokenBarHCollection`
properties:
%(BrokenBarHCollection)s
these can either be a single argument, ie::
facecolors = 'black'
or a sequence of arguments for the various bars, ie::
facecolors = ('black', 'red', 'green')
**Example:**
.. plot:: mpl_examples/pylab_examples/broken_barh.py
R� ( R t BrokenBarHCollectionR� R R� ( R2 t xrangest yrangeRI t col( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt broken_barh� s '
s b-s r-c C s1 | j } | j s | j � n | j t � | j | | | d d �\ } | d k r_ d } n g }
xT t | | � D]C \ } } | j | | g | | g | d d �\ }
|
j |
� qu W| j t j | � t j
| � g | | g | d d �\ } | j | � t | |
| f d | �} | j | � | S( s�
Create a stem plot.
Call signature::
stem(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')
A stem plot plots vertical lines (using *linefmt*) at each *x*
location from the baseline to *y*, and places a marker there
using *markerfmt*. A horizontal line at 0 is is plotted using
*basefmt*.
Return value is a tuple (*markerline*, *stemlines*,
*baseline*).
.. seealso::
This `document <http://www.mathworks.com/help/techdoc/ref/stem.html>`_
for details.
**Example:**
.. plot:: mpl_examples/pylab_examples/stem_plot.py
R� RA i N(
R� R� Rd R R. R Ru R{ R[ Rg Rh R R� ( R2 R` Ra t linefmtt markerfmtt basefmtR� R� t
remember_holdt
markerlinet stemlinesR! R R� R% t stem_container( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt stem� s&
*
g333333�?g�������?c
C s� | j t � t j | � j t j � } t | j � � } | d k r[ t j | | � } n | d k r} d g t
| � } n | d k r� d g t
| � } n | d k r� d } n d } |
d k r� d }
n | d k r� d }
n
| d }
g } g } g } d } x�t j | | | � D]m\ } } } | \ } } |
| } d
t
j d |
| } | | t
j | � 7} | | t
j | � 7} t j | | f |
d |
d | d | | t
| � �} | j | � | j | � | j | � | r8t j | d d � } | j d | j � � | j d � | j | � n | | |
t
j | � } | | |
t
j | � } | d k r�d p�d } | j | | | d t d d | d d �} | j | � | d k ry| | |
t
j | � } | | |
t
j | � } t | � r | d | } n+ t | � r<| d | � } n t d � � | j | | | d d d d �} | j | � n | }
| d 7} q W| j d! � | j d" � | j g � | j! g � | d k r�| | f S| | | f Sd S(# sD
Plot a pie chart.
Call signature::
pie(x, explode=None, labels=None,
colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'),
autopct=None, pctdistance=0.6, shadow=False,
labeldistance=1.1, startangle=None, radius=None)
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 wedges are plotted counterclockwise,
by default starting from the x-axis.
Keyword arguments:
*explode*: [ *None* | len(x) sequence ]
If not *None*, is a ``len(x)`` array which specifies the
fraction of the radius with which to offset each wedge.
*colors*: [ *None* | color sequence ]
A sequence of matplotlib color args through which the pie chart
will cycle.
*labels*: [ *None* | len(x) sequence of strings ]
A sequence of strings providing the labels for each wedge
*autopct*: [ *None* | format string | format function ]
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*: scalar
The ratio between the center of each pie slice and the
start of the text generated by *autopct*. Ignored if
*autopct* is *None*; default is 0.6.
*labeldistance*: scalar
The radial distance at which the pie labels are drawn
*shadow*: [ *False* | *True* ]
Draw a shadow beneath the pie.
*startangle*: [ *None* | Offset angle ]
If not *None*, rotates the start of the pie chart by *angle*
degrees counterclockwise from the x-axis.
*radius*: [ *None* | scalar ]
The radius of the pie, if *radius* is *None* it will be set to 1.
The pie chart will probably look best if the figure and axes are
square. Eg.::
figure(figsize=(8,8))
ax = axes([0.1, 0.1, 0.8, 0.8])
Return value:
If *autopct* is *None*, return the tuple (*patches*, *texts*):
- *patches* is a sequence of
:class:`matplotlib.patches.Wedge` instances
- *texts* is a list of the label
:class:`matplotlib.text.Text` instances.
If *autopct* is not *None*, return the tuple (*patches*,
*texts*, *autotexts*), where *patches* and *texts* are as
above, and *autotexts* is a list of
:class:`~matplotlib.text.Text` instances for the numeric
labels.
i R i Rc t gRM R% R
Ra R} R� g �v@i g �?Rk g{�G�z��g�������?RA R� R� R! s xtick.labelsizeR& R$ R� g Y@s+ autopct must be callable or a format stringg �g �?N( Rc R� RM R% R
Ra R} R� ( i i ( g �g �?( g �g �?(" RY R
R[ R� t astypet float32Rw t sumt divideR Rt R) t safezipRs t pit cost sinRo t WedgeR{ R� R� t ShadowR. t
get_zorderR" R R R� RN R. R: R� R� ( R2 R` t explodeR� R t autopctt pctdistancet shadowt
labeldistancet
startangleR� t sxR� t theta1R� t slicest autotextsRn t fracR� t explRa t theta2t thetamR� t shadR� R� t label_alignmentRN R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt pie s� M
%
#
t -i c 1 K s�
| d k r t d � � n | j d | d | d | � | j sM | j � n | j } t | _ | j d d � } t | � s� | g } n t | � s� | g } n | d k r� t | � s� | g t | � } q� n | d k rt | � s| g t | � } qn d } | r?| d k r?| j | | | d d | �\ } n g } g } i d d 6} | rk| | d <n: d | k r�| d | d <n d | k r�| d | d <n d
| k r�| d
| d
<n t |
� s�t
j |
g t | � t � }
n t
j |
t � }
t | � s0t
j
| g t | � t � } n t
j | t � } t | � spt
j
| g t | � t � } n t
j | t � } t |
� s�t
j
|
g t | � t � }
n t
j |
t � }
t
j t | � � | d k } d � } | d k r�i d
| d 6d d 6} | d k r'| | d <n d | k rD| d | d <n d | k ra| d | d <n d
| k r�| d
| d
<q�n | d k r�t | � r4t | � d
k r4t | d � r4t | d � r4g t j | | d � D] \ } } | | ^ q�} g t j | | d � D] \ } } | | ^ q} n^ g t j | | � D] \ } } | | ^ qG} g t j | | � D] \ } } | | ^ qv} | | | | � \ } } | | | | � \ } }! | j | j | | |! | � � | d k r�| j � r�| | | | | @� \ }" }# | j | j |" |# d d d t j | �� | } | | | | | @� \ }" }# | j | j |" |# d | � � n7 | | | | � \ }" }# | j | j |" |# d | � � |
j � rT| | | |
| @� \ }$ }% | j | j |$ |% d d d t j | �� |
}
| | | |
| @� \ }$ }% | j | j |$ |% d | � � q�| | | | � \ }$ }% | j | j |$ |% d | � � q�n | d k r� t | � rDt | � d
k rDt | d � rDt | d � rDg t j | | d � D] \ }& } |& | ^ q�}' g t j | | d � D] \ }& } |& | ^ q%}( n^ g t j | | � D] \ }& } |& | ^ qW}' g t j | | � D] \ }& } |& | ^ q�}( | | |' | � \ }) } | |' |( | � \ } }* | j | j |) | |* | � � | d k r� |
j � r�| | |' |
| @� \ }+ }, | j | j |+ |, d d d t j | �� |
}
| | |' |
| @� \ }+ }, | j | j |+ |, d | � � n7 | | |' | � \ }+ }, | j | j |+ |, d | � � | j � rd | | |( | | @� \ }- }. | j | j |- |. d d d t j | �� | } | | |( | | @� \ }- }. | j | j |- |. d | � � q� | | |( | � \ }- }. | j | j |- |. d | � � q� n | r� | d k r� | j | | | | � \ } n | d k r
| d k r� | j j j � } q
| j � } n x | D] }/ |/ j | � q
Wx | D] }/ |/ j | � q3
W| j � | | _ t! | t" | � t" | � f d | d k d | d k d | �}0 | j# j |0 � |0 S( s�
Plot an errorbar graph.
Call signature::
errorbar(x, y, yerr=None, xerr=None,
fmt='-', ecolor=None, elinewidth=None, capsize=3,
barsabove=False, lolims=False, uplims=False,
xlolims=False, xuplims=False, errorevery=1,
capthick=None)
Plot *x* versus *y* with error deltas in *yerr* and *xerr*.
Vertical errorbars are plotted if *yerr* is not *None*.
Horizontal errorbars are plotted if *xerr* is not *None*.
*x*, *y*, *xerr*, and *yerr* can all be scalars, which plots a
single error bar at *x*, *y*.
Optional keyword arguments:
*xerr*/*yerr*: [ scalar | N, Nx1, or 2xN array-like ]
If a scalar number, len(N) array-like object, or an Nx1 array-like
object, errorbars are drawn +/- value.
If a sequence of shape 2xN, errorbars are drawn at -row1 and
+row2
*fmt*: '-'
The plot format symbol. If *fmt* is *None*, only the
errorbars are plotted. This is used for adding
errorbars to a bar plot, for example.
*ecolor*: [ *None* | mpl color ]
A matplotlib color arg which gives the color the errorbar lines;
if *None*, use the marker color.
*elinewidth*: scalar
The linewidth of the errorbar lines. If *None*, use the linewidth.
*capsize*: scalar
The length of the error bar caps in points
*capthick*: scalar
An alias kwarg to *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*: [ *True* | *False* ]
if *True*, will plot the errorbars above the plot
symbols. Default is below.
*lolims* / *uplims* / *xlolims* / *xuplims*: [ *False* | *True* ]
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*.
*errorevery*: positive integer
subsamples the errorbars. Eg if everyerror=5, errorbars for every
5-th datapoint will be plotted. The data plot itself still shows
all data points.
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 *markeredgewith*.
valid kwargs for the marker properties are
%(Line2D)s
Returns (*plotline*, *caplines*, *barlinecols*):
*plotline*: :class:`~matplotlib.lines.Line2D` instance
*x*, *y* plot markers and/or line
*caplines*: list of error bar cap
:class:`~matplotlib.lines.Line2D` instances
*barlinecols*: list of
:class:`~matplotlib.collections.LineCollection` instances for
the horizontal and vertical error ranges.
**Example:**
.. plot:: mpl_examples/pylab_examples/errorbar_demo.py
i s0 errorevery has to be a strictly positive integerR R RI R� RA RV R� R� i c S sf g t | | � D] \ } } | r | ^ q } g t | | � D] \ } } | r> | ^ q> } | | f S( so
return xs[mask], ys[mask] where mask is True but xs and
ys are not arrays
( Ru ( R� R� R, R! Rc R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt xywhereV s ..i t mst markeredgewidtht mewt lsR R" s k|t k_t has_xerrt has_yerrN($ R R R� R� R RC R R� Rt R. R[ R� R R� Rv R) R� R{ R R� R- R t CARETLEFTt
CARETRIGHTR$ t CARETDOWNt CARETUPR@ R; Rf t get_colort set_colorR� R R� RF (1 R2 R` Ra RX RW R RZ t
elinewidthR[ t barsabovet lolimst uplimst xlolimst xuplimst
erroreveryt capthickRI Rp R� t l0t barcolst caplinest lines_kwt everymaskR� t plot_kwR! t thiserrR� R� t yoR� t lot rot leftlot ylot rightupt yupR R� R~ t xot uot xlot lowerlot xupt upperupR� t errorbar_container( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRf � s$ h
$
" " " "
03,, " "% 03,, " "%
s b+g �?c = s� d d � � � f d � } � j s1 � j � n � j }
g g g g g f \ } } } } } t | d � rKt | j � d k r� t | d d � r� t | � } qH| g } qKt | j � d k r<| j \ } } | d k r� | g } qH| d k r
| j � g } qHg t | � D] } | d d � | f ^ q} qKt d � � n t | d d
� sj| g } n t | � } d } d } |
d k r
t |
d � r�t |
j � d k r�t | � � q|
j d | k rt | � � qq
t |
� | k r
t | � � q
n d
} d } d } | d k rt | d � r�t | j � d k r[t | � � q| j d | k r}t | � � q| j d d k rt | � � qqt | � | k r�t | � � n x> | D]3 } | d k r�t | � d k r�t | � � q�q�Wn | d k r&t
d | d � } n | d k rgt | � t | � } t d t | d � d � } n t
| t � s�t
| t � r�t j | f t � | } n � j t � x�t | � D]�\ } } t j | | � } t | � } | d k r�q�n t j | d d d g � \ } } }! |
d k rH|
| d k rH|
| } qHn |! | }" |! | |" }# t j | |# k | � }$ t |$ � d k r�|! }$ n t |$ � }$ | | |" }% t j | |% k | � }& t |& � d k r�| }& n t |& � }& g }' g }( g }) g }* t | � d k r}t j | |$ k | � }' t j | |& k | � }( t j |' j d � | }) t j |( j d � | }* n | | | d }+ | | | d }, t j d � | }- | | | d }. | | | d }/ |. |/ g }0 | | g }1 | r�| d k r;| | d k r;t j | | � }2 t j | | � }3 n | | | |" | � \ }3 }2 |+ |, |, |/ |, |, |+ |+ |. |+ |+ g }4 | | |3 | |2 |! |! |2 | |3 | g }5 |. |/ g }6 | | g }1 n6 |+ |, |, |+ |+ g }4 | | |! |! | g }5 |+ |, g }6 d � � � � f d � � | r7� f d � }7 � f d � }8 n � f d � }7 � f d � }8 | rdd }9 n d }9 | j |7 |- | |& g d |- |! |$ g d � � | j |7 |0 |$ |$ g d |0 |& |& g d � � | r�| j |8 |4 |5 � � n | j |7 |4 |5 d! � � | j |7 |6 |1 |9 d" � � | j |7 |) |' | |* |( | � � q�W| r]� j � j }: }; n � j � j }: }; t | � d t | � d f }< |; |< � |: | � � j |
� t d# | d$ | d% | d& | d' | � S(( s�
Make a box and whisker plot.
Call signature::
boxplot(x, notch=False, sym='+', vert=True, whis=1.5,
positions=None, widths=None, patch_artist=False,
bootstrap=None, usermedians=None, conf_intervals=None)
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.
Function Arguments:
*x* :
Array or a sequence of vectors.
*notch* : [ False (default) | True ]
If False (default), produces a rectangular box plot.
If True, will produce a notched box plot
*sym* : [ default 'b+' ]
The default symbol for flier points.
Enter an empty string ('') if you don't want to show fliers.
*vert* : [ False | True (default) ]
If True (default), makes the boxes vertical.
If False, makes horizontal boxes.
*whis* : [ default 1.5 ]
Defines the length of the whiskers as a function of the inner
quartile range. They extend to the most extreme data point
within ( ``whis*(75%-25%)`` ) data range.
*bootstrap* : [ *None* (default) | integer ]
Specifies whether to bootstrap the confidence intervals
around the median for notched boxplots. If bootstrap==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 it's 95% confidence intervals.
Values between 1000 and 10000 are recommended.
*usermedians* : [ default None ]
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* == None, the median will be
computed directly as normal.
*conf_intervals* : [ default None ]
Array or sequence whose first dimension (or length) is compatible
with *x* and whose second dimension is 2. When the current element
of *conf_intervals* is not None, the notch locations computed by
matplotlib are overridden (assuming notch is True). When an element of
*conf_intervals* is None, boxplot compute notches the method
specified by the other kwargs (e.g. *bootstrap*).
*positions* : [ default 1,2,...,n ]
Sets the horizontal positions of the boxes. The ticks and limits
are automatically set to match the positions.
*widths* : [ default 0.5 ]
Either a scalar or a vector and sets the width of each box. The
default is 0.5, or ``0.15*(distance between extreme positions)``
if that is smaller.
*patch_artist* : [ False (default) | True ]
If False produces boxes with the Line2D artist
If True produces boxes with the Patch artist
Returns 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: horizonal lines at the median of each box.
- whiskers: the vertical lines extending to the most extreme,
n-outlier data points.
- caps: the horizontal lines at the ends of the whiskers.
- fliers: points representing data that extend beyone the
whiskers (outliers).
**Example:**
.. plot:: pyplots/boxplot_demo.py
i� c S s� t | � } d d g } t j | � } xP t | � D]B } t j j d | d | � } | | } t j | d � | | <q4 Wt j | | � } | S( Ng @g `X@i i i2 ( Rt R[ t zerost ranget randomt random_integerst mlabt prctile( t datat Nt Mt
percentilet estimateRi t bsIndext bsDatat CI( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt bootstrapMedianL s
c s� | d k r5 � | d | �} | d } | d } nB t | � } | d | t j | � } | d | t j | � } | | f S( NR� i i g ��Q� �?( R Rt R[ R� ( R� t medt iqt bootstrapR� t notch_mint notch_maxR� ( R� ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt computeConfIntervalX s
R] i i i Ns* input x can have no more than 2 dimensionst __len__s5 usermedians must either be a list/tuple or a 1d arrays- usermedians' length must be compatible with xs< conf_intervals must either be a list of tuples or a 2d arrays0 conf_intervals' length must be compatible with xs8 each conf_interval, if specificied, must have two valuesg333333�?g �?g �?i i2 iK g �?c S s� g } x0 t | | � D] \ } } | j | | f � q W| j d � t j j g t j j g t | � d t j j g } | | f S( Ni i ( i i ( Ru R{ t mpatht Patht MOVETOt LINETORt t CLOSEPOLY( R� R� R� t xit yit codes( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt to_vc s
'c sJ � | | � \ } } t j | | � } t j | � } � j | � | g S( N( R� R� Ro t PathPatchR� ( R� R� R� R� R� RN ( R2 R� ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
patch_list s
c s
� j | � S( N( R. ( RH ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt doplot s c s
� | | � S( N( ( R� R� ( R� ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt dopatch s c s` g } xJ t d t | � d � D]0 } | j | | d | | | | d g � q W� j | � S( Ni i i i ( Ry Rt R- R. ( RH t shuffledRn ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s .c s | | } } � | | � S( N( ( R� R� ( R� ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� s
R} RM s b--s k-s b-R� t whiskerst capst boxest medianst fliers( R� R� RM Rt R] Rc t ravelRy R R R� Rz R� R� Rw R R[ t onesRd R t enumerateR� R� t compressR- R� R. R� R: Ru (= R2 R` t notcht symt vertt whist positionst widthst patch_artistR� t usermedianst conf_intervalsR� t
holdStatusR� R� R� R� R� t nrt ncRn Rw t msg1t msg2t msg3t cit distanceR
R1 t rowt q1R� t q3R� t hi_valt wisk_hit lo_valt wisk_lot flier_hit flier_lot
flier_hi_xt
flier_lo_xt box_x_mint box_x_maxt wisk_xt cap_x_mint cap_x_maxt cap_xt med_yR� R� t box_xt box_yt med_xR� R� t median_colort settickst setlimt newlimits( ( R� R� R2 R� s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt boxplot� s `
$ 2
$
i Rc R7 c K s� | j s | j � n | j d | d | d | � | j | � } | j | � } t j j | � } t j j | � } | j | j k r� t d � � n t j j | � } t
| � p� t | � } | s� t j | � } | j | j k r� t j j | � } q� n t
j | | | | � \ } } } } | } | rFt j j | |
� } n0 | j | j k rad } n t j j | |
� } | r�d } n d } t j d t � d } d } | d k r�|
d k r�|
d f } d }
n t j | � } | j � j | j � � } | j � sd } n t j | f | d | d
| d | d t | | � d
| j d | j � �} | j! t" j# � � | j$ |
� | j% | � | d k r| d k r�n | j& t j' | � � | j( | � | j) | � | d k s�| d k r| j* | | � q| j+ � n | j, d k r<| j d k r<| j- d � n | j. d k rj| j d k rj| j/ d � n | j0 | � | j1 � | S( s�
Make a scatter plot.
Call signatures::
scatter(x, y, s=20, c='b', marker='o', cmap=None, norm=None,
vmin=None, vmax=None, alpha=None, linewidths=None,
verts=None, **kwargs)
Make a scatter plot of *x* versus *y*, where *x*, *y* are
converted to 1-D sequences which must be of the same length, *N*.
Keyword arguments:
*s*:
size in points^2. It is a scalar or an array of the same
length as *x* and *y*.
*c*:
a color. *c* can be a single color format string, or a
sequence of color specifications of length *N*, or a
sequence of *N* numbers to be mapped to colors using the
*cmap* and *norm* specified via kwargs (see below). 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. *c* can be a 2-D array in
which the rows are RGB or RGBA, however.
*marker*:
can be one of:
%(MarkerTable)s
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.
Other keyword arguments: the color mapping and normalization
arguments will be used only if *c* is an array of floats.
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance or registered
name. If *None*, defaults to rc ``image.cmap``. *cmap* is
only used if *c* is an array of floats.
*norm*: [ *None* | Normalize ]
A :class:`matplotlib.colors.Normalize` instance is used to
scale luminance data to 0, 1. If *None*, use the default
:func:`normalize`. *norm* is only used if *c* is an array
of floats.
*vmin*/*vmax*:
*vmin* and *vmax* are used in conjunction with norm to
normalize luminance data. If either are *None*, the min and
max of the color array *C* is used. Note if you pass a
*norm* instance, your settings for *vmin* and *vmax* will
be ignored.
*alpha*: ``0 <= scalar <= 1`` or *None*
The alpha value for the patches
*linewidths*: [ *None* | scalar | sequence ]
If *None*, defaults to (lines.linewidth,). Note that this
is a tuple, and if you set the linewidths argument you
must set it as a sequence of floats, as required by
:class:`~matplotlib.collections.RegularPolyCollection`.
Optional kwargs control the
:class:`~matplotlib.collections.Collection` properties; in
particular:
*edgecolors*:
The string 'none' to plot faces with no outlines
*facecolors*:
The string 'none' to plot unfilled outlines
Here are the standard descriptions of all the
:class:`~matplotlib.collections.Collection` kwargs:
%(Collection)s
A :class:`~matplotlib.collections.Collection` instance is
returned.
R R RI s x and y must be the same sizet nones0 replace "faceted=False" with "edgecolors='none'"i t facet
facecolorst
edgecolorst
linewidthst offsetst transOffsetR� g�������?N(2 R� R� R RY RZ R[ R R� R! R R t is_sequence_of_stringst
asanyarrayR) t delete_masked_pointsR R Rd R R( R) R* t mmarkerst MarkerStyleR� R� R t is_filledR t PathCollectionRu RC R� R R� R� t set_alphaR� t set_arrayR� t set_cmapt set_normt set_climt autoscale_NoneR= R R> R R� R� ( R2 R` Ra R R% R" t cmapt normt vmint vmaxR� R& t facetedR� RI t c_is_stringyt scalesR R% R� t symstylet
marker_objR� R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt scatterE s� [
$
id R R" c D sw | j s | j � n | j d | d | d | � t j | | | � \ } } } t | � rk | \ } } n | } t | t j d � � } t j
| t � } t j
| t � } | d k r� t j | d k � r� t
d � � n t j | � } n | d k r2t j | d k � r t
d � � n t j | � } n | d k rS| \ } } } } n< t j | � } t j | � } t j | � } t j | � } d | | } | | 8} | | 7} | | | } | | | } | r�| j � } | j � } n | | | } | | | } t j | � j t � } t j | � j t � } t j | � j t � }! t j | � j t � }" | d
}# | d
}$ | }% | }& |# |$ |% |& }' | | d d | | d }( | |! d
d d | |" d
d }) |( |) k }* | d k r6t j |' � }+ |+ |# |$ }, |+ |# |$ }- |# |$ f |, _ |% |& f |- _ x� t t | � � D]� }. |* |. r�| |. d k r)| |. |# k r)| |. d k r)| |. |$ k r)|, | |. | |. f c d
7<q)qT|! |. d k rT|! |. |% k rT|" |. d k rT|" |. |& k rT|- |! |. |" |. f c d
7<qTqTW| d k r�xW t |# � D]I }. x@ t |$ � D]2 }/ |, |. |/ f | k rYt j |, |. |/ f <qYqYWqFWxZ t |% � D]I }. x@ t |& � D]2 }/ |- |. |/ f | k r�t j |- |. |/ f <q�q�Wq�Wn t j |, j t � j � |- j t � j � f � }+ t j |+ � }0 n�| d k rKd } n t j |# |$ f d t �}, x; t |# � D]- }. x$ t |$ � D] }/ g |, |. |/ f <q�WqsWt j |% |& f d t �}- x; t |% � D]- }. x$ t |& � D] }/ g |- |. |/ f <q�Wq�Wx� t t | � � D]� }. |* |. r�| |. d k r�| |. |# k r�| |. d k r�| |. |$ k r�|, | |. | |. f j | |. � q�q|! |. d k r|! |. |% k r|" |. d k r|" |. |& k r|- |! |. |" |. f j | |. � qqWxy t |# � D]k }. xb t |$ � D]T }/ |, |. |/ f }1 t |1 � | k rT� |1 � |, |. |/ f <qt j |, |. |/ f <qWq Wxy t |% � D]k }. xb t |& � D]T }/ |- |. |/ f }1 t |1 � | k r�� |1 � |- |. |/ f <q�t j |- |. |/ f <q�Wq|Wt j |, j t � j � |- j t � j � f � }+ t j |+ � }0 t j |' d f t � }2 t j! t j" |# � |$ � |2 d |# |$ � d f <t j# t j" |$ � |# � |2 d |# |$ � d
f <t j! t j" |% � d
|& � |2 |# |$ d � d f <t j# t j" |& � |% � d
|2 |# |$ d � d
f <|2 d d � d f c | 9<|2 d d � d
f c | 9<|2 d d � d f c | 7<|2 d d � d
f c | 7<|2 |0 d d � f }2 |+ |0 }+ | d k r� d |2 d d � d f |2 d d � d f <d | } d | } | j$ d � n | d k rN
d |2 d d � d
f |2 d d � d
f <d | } d | } | j% d � n t j d% t � }3 | t j
d
d
d d d d g � |3 d d � d f <| t j
d d
d d
d d g � d |3 d d � d
f <| d k r�
d } n t& j' |3 g d | d | d |2 d t( j) � d d �}4 t* |
t+ j, � rM |+ d k j � rM |+ d
7}+ qM n |
d k r� |
j- d k r� |
j. d k r� |
j/ |+ � q� n | d k r� t j |+ d
� }+ n~ | d k r* t | � s t0 |+ � t1 |+ � }5 }6 | d
8} |5 |6 |5 t j" | � | } n t j2 | � } | j3 |+ � }+ n |
d k r9 n |4 j4 |+ � |4 j5 | � |4 j6 |
� |4 j7 |
� |4 j8 | � | d k s� | d k r� |4 j9 | | � n
|4 j: � | | f | | f f }7 | j; |7 � | j< d t= � | j> |4 � | s� |4 S| d k r
t j? t | � � } n � f d � }8 t j@ | | | � }9 |8 | | |9 � }: t j |: � }; g g }< }= x� tA |: � D]� \ }. }> |9 |. }? |. t |9 � d
k r�
|9 |. d
}@ n |? t jB |9 � d }@ |; |. s�
q
n |< j |? d f |? d! f |@ d! f |@ d f g � |= j |> � q
Wt j
|= � }= t( jC | jD | jE � }A t& j' |< d" |A d d �� � j4 |= � � j5 | � � j6 |
� � j7 |
� � j8 | � | j> � � t j@ | | | � }9 |8 | | |9 � }B t j |B � }; g g }< }= x� tA |B � D]� \ }. }> |9 |. }? |. t |9 � d
k rC|9 |. d
}@ n |? t jB |9 � d }@ |; |. sjqn |< j d |? f d |@ f d! |@ f d! |? f g � |= j |> � qWt j
|= � }= t( jC | jE | jD � }A t& j' |< d" |A d d �� � j4 |= � � j5 | � � j6 |
� � j7 |
� � j8 | � | j> � � � |4 _F � |4 _G � � f d# � }C |4 jH jI d$ |C � |4 S(& sv
Make a hexagonal binning plot.
Call signature::
hexbin(x, y, C = None, gridsize = 100, bins = None,
xscale = 'linear', yscale = 'linear',
cmap=None, norm=None, vmin=None, vmax=None,
alpha=None, linewidths=None, edgecolors='none'
reduce_C_function = np.mean, mincnt=None, marginals=True
**kwargs)
Make a hexagonal binning plot of *x* versus *y*, where *x*,
*y* are 1-D sequences of the same length, *N*. If *C* is *None*
(the default), this is a histogram of the number of occurences
of the observations at (x[i],y[i]).
If *C* is specified, it specifies values at the coordinate
(x[i],y[i]). These values are accumulated for each hexagonal
bin and then reduced according to *reduce_C_function*, which
defaults to numpy's mean function (np.mean). (If *C* is
specified, it must also be a 1-D sequence of the same length
as *x* and *y*.)
*x*, *y* and/or *C* may be masked arrays, in which case only
unmasked points will be plotted.
Optional keyword arguments:
*gridsize*: [ 100 | integer ]
The number of hexagons in the *x*-direction, default is
100. The corresponding number of hexagons in the
*y*-direction is chosen such that the hexagons are
approximately regular. Alternatively, gridsize can be a
tuple with two elements specifying the number of hexagons
in the *x*-direction and the *y*-direction.
*bins*: [ *None* | 'log' | integer | sequence ]
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.
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' ]
Use a linear or log10 scale on the horizontal axis.
*scale*: [ 'linear' | 'log' ]
Use a linear or log10 scale on the vertical axis.
*mincnt*: [ *None* | a positive integer ]
If not *None*, only display cells with more than *mincnt*
number of points in the cell
*marginals*: [ *True* | *False* ]
if marginals is *True*, plot the marginal density as
colormapped rectagles along the bottom of the x-axis and
left of the y-axis
*extent*: [ *None* | scalars (left, right, bottom, top) ]
The limits of the bins. The default assigns the limits
based on gridsize, x, y, xscale and yscale.
Other keyword arguments controlling color mapping and normalization
arguments:
*cmap*: [ *None* | Colormap ]
a :class:`matplotlib.colors.Colormap` instance. If *None*,
defaults to rc ``image.cmap``.
*norm*: [ *None* | Normalize ]
:class:`matplotlib.colors.Normalize` instance is used to
scale luminance data to 0,1.
*vmin* / *vmax*: scalar
*vmin* and *vmax* are used in conjunction with *norm* to normalize
luminance data. If either are *None*, the min and max of the color
array *C* is used. Note if you pass a norm instance, your settings
for *vmin* and *vmax* will be ignored.
*alpha*: scalar between 0 and 1, or *None*
the alpha value for the patches
*linewidths*: [ *None* | scalar ]
If *None*, defaults to rc lines.linewidth. Note that this
is a tuple, and if you set the linewidths argument you
must set it as a sequence of floats, as required by
:class:`~matplotlib.collections.RegularPolyCollection`.
Other keyword arguments controlling the Collection properties:
*edgecolors*: [ *None* | ``'none'`` | mpl color | color sequence ]
If ``'none'``, draws the edges in the same color as the fill color.
This is the default, as it avoids unsightly unpainted pixels
between the hexagons.
If *None*, draws the outlines in the default color.
If a matplotlib color arg or sequence of rgba tuples, draws the
outlines in the specified color.
Here are the standard descriptions of all the
:class:`~matplotlib.collections.Collection` kwargs:
%(Collection)s
The return value is a
:class:`~matplotlib.collections.PolyCollection` instance; use
:meth:`~matplotlib.collections.PolyCollection.get_array` on
this :class:`~matplotlib.collections.PolyCollection` to get
the counts in each hexagon. If *marginals* is *True*, horizontal
bar and vertical bar (both PolyCollections) will be attached
to the return collection as attributes *hbar* and *vbar*.
**Example:**
.. plot:: mpl_examples/pylab_examples/hexbin_demo.py
R R RI i R~ g s8 x contains non-positive values, so can not be log-scaleds8 y contains non-positive values, so can not be log-scaledg��&� .>i i g @g �?i Rs Ni
i g �g �?g �R" R# R% R& R' R( t offset_positionR� R� c s{ | j | � j d t | � d � } t j t | � � } x: t t | � � D]& } � | | | k � } | | | <qM W| S( Ni i ( t searchsortedt clipRt R[ R� R� ( R` Ra t coarset indt musRn t mu( t reduce_C_function( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
coarse_bini s %i����g�������?R� c sP � j | j � � � j | j � � � j | j � � � j | j � � d S( N( R2 t get_cmapR4 t get_clim( R� ( t hbart vbar( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
on_changed� s t changed( i i (J R� R� R R) R+ R� R Rs R� R[ R� Rw R� R R| R Rg Rh R5 R9 R� t floorR� R] Ry Rt t nanRq R� t isnant emptyt objectR{ t repeatRv t tileR� R� R t PolyCollectionR� R� R� R t LogNormR8 R9 R R� Rz R3 RA R1 R2 R3 R0 R� R4 R5 R� R� R R� R� t linspaceR� t diffR� R� R� RK RL t callbacksSMR� (D R2 R` Ra R� t gridsizet binsR� R� t extentR6 R7 R8 R9 R� R& R% RG t mincntt marginalsRI t nxt nyRu Rv Rw Rx t paddingR� t syt xorigt yorigt ix1t iy1t ix2t iy2t nx1t ny1t nx2t ny2Ri t d1t d2t bdistt accumt lattice1t lattice2Rn R� t good_idxst valsR' t polygonR� t minimumt maximumR RH RC t xcoarset validR� t valuesRR t thismint thismaxR� t ycoarseRM ( ( RK RG RL s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt hexbin s� �
&
$ % !-
) *-//33
*
*
59
"
1
1
c K sh | j | � } | j | � } | j | � } | j | � } t j | | | | | � } | j | � | S( s�
Add an arrow to the axes.
Call signature::
arrow(x, y, dx, dy, **kwargs)
Draws arrow on specified axis from (*x*, *y*) to (*x* + *dx*,
*y* + *dy*). Uses FancyArrow patch to construct the arrow.
Optional kwargs control the arrow construction and properties:
%(FancyArrow)s
**Example:**
.. plot:: mpl_examples/pylab_examples/arrow_demo.py
( RY RZ Ro t
FancyArrowR� ( R2 R` Ra R� R� RI R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt arrow� s
c O s# t j | | � } | j | � | S( N( t mquivert QuiverKeyR� ( R2 RH Rh t qk( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt quiverkey� s
c O sY | j s | j � n t j | | | � } | j | t � | j | j � | j � | S( N( R� R� R� t QuiverR� R
R� t XYR� ( R2 RH Rh t q( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt quiver� s
c O s t j | | | | � S( N( t mstackt stackplot( R2 R` RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s s -|>g�������?c C sk | j s | j � n t j | | | | | d | d | d | d | d | d |
d | d | d |
� } | S(
Nt densityRV R# R6 R7 t arrowsizet
arrowstylet minlengthR� ( R� R� t mstreamt
streamplot( R2 R` Ra t uR~ R� RV R# R6 R7 R� R� R� R� t stream_container( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s
c O sY | j s | j � n t j | | | � } | j | � | j | j � � | j � | S( sq
%(barbs_doc)s
**Example:**
.. plot:: mpl_examples/pylab_examples/barb_demo.py
( R� R� R� t BarbsR� R� t get_offsetsR� ( R2 RH Rh Rc ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt barbs� s
c O sa | j s | j � n g } x4 | j | | � D] } | j | � | j | � q/ W| j � | S( s�
Plot filled polygons.
Call signature::
fill(*args, **kwargs)
*args* is a variable length argument, allowing for multiple
*x*, *y* pairs with an optional color format string; see
:func:`~matplotlib.pyplot.plot` for details on the argument
parsing. For example, to plot a polygon with vertices at *x*,
*y* in blue.::
ax.fill(x,y, 'b' )
An arbitrary number of *x*, *y*, *color* groups can be specified::
ax.fill(x1, y1, 'g', x2, y2, 'r')
Return value is a list of :class:`~matplotlib.patches.Patch`
instances that were added.
The same color strings that :func:`~matplotlib.pyplot.plot`
supports are supported by the fill format string.
If you would like to fill below a curve, eg. shade a region
between 0 and *y* along *x*, use :meth:`fill_between`
The *closed* kwarg will close the polygon when *True* (default).
kwargs control the :class:`~matplotlib.patches.Polygon` properties:
%(Polygon)s
**Example:**
.. plot:: mpl_examples/pylab_examples/fill_demo.py
( R� R� RA R� R{ R� ( R2 RH RI R� t poly( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRl s )
c s� | j d � d � d | � | j d � � t j | j � � � � t j | j � � � � t j | j � � � � � j d k r� t j � � � � n � j d k r� t j � � � � n | d
k r� t j t
� � t j � } n t j | t j � } � j
� j
k o+� j
k o+| j
k n s?t d � � n t t j g � � � f D] } t j | � ^ qX� } | t j k r�| | M} n g } x�t j | � D]y\ }
} � |
| !} � |
| !}
� |
| !} t
| � s�q�n t
| � } t j d | d d f t j � } | rS� � � f d � } | |
� } | | � } n( | d | d f } | d | d f } | | d <| | | d <| | d | d � d f <|
| d | d � d f <| d
d
d � | | d d
� d f <| d
d
d � | | d d
� d f <| j | � q�Wt j | | � } t j � | � | g � j } t j � | � | g � j } | j j | | j d t d t �| j j | | j d t d t �| j! | � | j" � | S(
s�
Make filled polygons between two curves.
Call signature::
fill_between(x, y1, y2=0, where=None, **kwargs)
Create a :class:`~matplotlib.collections.PolyCollection`
filling the regions between *y1* and *y2* where
``where==True``
*x* :
An N-length array of the x data
*y1* :
An N-length array (or scalar) of the y data
*y2* :
An N-length array (or scalar) of the y data
*where* :
If *None*, default to fill between everywhere. If not *None*,
it is an N-length numpy boolean array and the fill will
only happen over the regions where ``where==True``.
*interpolate* :
If *True*, interpolate between the two lines to find the
precise point of intersection. Otherwise, the start and
end points of the filled region will only occur on explicit
values in the *x* array.
*kwargs* :
Keyword args passed on to the
:class:`~matplotlib.collections.PolyCollection`.
kwargs control the :class:`~matplotlib.patches.Polygon` properties:
%(PolyCollection)s
.. plot:: mpl_examples/pylab_examples/fill_between_demo.py
.. seealso::
:meth:`fill_betweenx`
for filling between two sets of x-values
R R RI i s$ Argument dimensions are incompatiblei c s t | d d � } � | | d !} � | | d !� | | d !} � | | d !} t | � d k r� t j j | d � r� � | � | f St j j | d � r� � | � | f Sn | j � } t j d | | | | � } t j | | | � } | | f S( Ni i i ( Rz Rt R[ R t is_maskedt argsortt interp( RD t im1t x_valuest diff_valuest y1_valuest
diff_ordert diff_root_xt diff_root_y( R` R^ R� ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_interp_point� s i����i NR� R� (# R R t masked_invalidRY RZ R^ R[ t ones_likeR R� Rt R R� R] R t reducet mask_ort getmaskt nomaskR� t contiguous_regionsR� Rw R{ R RV R� R R� R� R( R R
R� R� ( R2 R` R^ R� RP t interpolateRI R R, t polyst ind0t ind1t xslicet y1slicet y2sliceR� t XR� R� t endR� t XY1t XY2( ( R` R^ R� s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt fill_betweenA sb 3 37
#
''
c K s� | j d | d | d | � | j d | � t j | j | � � } t j | j | � � } t j | j | � � } | j d k r� t j | � | } n | j d k r� t j | � | } n | d k r� t j t
| � t j � } n t j | t j � } | j
| j
k o+| j
k o+| j
k n s?t d � � n t t j g | | | f D] } t j | � ^ qX� } | t j k r�| | M} n g } xHt j | � D]7\ } }
| | |
!} | | |
!} | | |
!}
t
| � s�q�n t
| � } t j d | d d f t j � } |
d | d f | d <|
d | d f | | d <| | d | d � d f <| | d | d � d f <|
d d d � | | d d � d f <| d d d � | | d d � d f <| j | � q�Wt j | | � } t j | | | | g � j } t j | | | | g � j } | j j | | j d
t d t �| j j | | j d
t d t �| j! | � | j" � | S( s~
Make filled polygons between two horizontal curves.
Call signature::
fill_between(y, x1, x2=0, where=None, **kwargs)
Create a :class:`~matplotlib.collections.PolyCollection`
filling the regions between *x1* and *x2* where
``where==True``
*y* :
An N-length array of the y data
*x1* :
An N-length array (or scalar) of the x data
*x2* :
An N-length array (or scalar) of the x data
*where* :
If *None*, default to fill between everywhere. If not *None*,
it is a N length numpy boolean array and the fill will
only happen over the regions where ``where==True``
*kwargs* :
keyword args passed on to the
:class:`~matplotlib.collections.PolyCollection`
kwargs control the :class:`~matplotlib.patches.Polygon` properties:
%(PolyCollection)s
.. plot:: mpl_examples/pylab_examples/fill_betweenx_demo.py
.. seealso::
:meth:`fill_between`
for filling between two sets of y-values
R R RI i s$ Argument dimensions are incompatiblei i����i NR� R� (# R R R� RZ RY R^ R[ R� R R� Rt R R� R] R R� R� R� R� R� R� R� Rw R{ R RV R� R R� R� R( R R
R� R� ( R2 Ra RX R� RP RI R R, R� R� R� t yslicet x1slicet x2sliceR� R R� t X1Yt X2Y( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
fill_betweenx� sV , 37
# ''
g @c sE � j s � j � n | d k r% n | d k r> t d } n � j | � t j � | | | | |
d | d |
d | | �} | j | � | j | � � j | � | j
� d k r� | j � j � n | d k s� | d k r� | j
| | � n
| j � | j | � | j | j � � � j j | � � f d � | _ | S( sz
Display an image on the axes.
Call signature::
imshow(X, cmap=None, norm=None, aspect=None, interpolation=None,
alpha=None, vmin=None, vmax=None, origin=None, extent=None,
**kwargs)
Display the image in *X* to current axes. *X* may be a float
array, a uint8 array or a PIL image. If *X* is an array, *X*
can have the following shapes:
* MxN -- luminance (grayscale, float array only)
* MxNx3 -- RGB (float or uint8 array)
* MxNx4 -- RGBA (float or uint8 array)
The value for each component of MxNx3 and MxNx4 float arrays should be
in the range 0.0 to 1.0; MxN float arrays may be normalised.
An :class:`matplotlib.image.AxesImage` instance is returned.
Keyword arguments:
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance, eg. cm.jet.
If *None*, default to rc ``image.cmap`` value.
*cmap* is ignored when *X* has RGB(A) information
*aspect*: [ *None* | 'auto' | 'equal' | scalar ]
If 'auto', changes the image aspect ratio to match that of the axes
If 'equal', and *extent* is *None*, changes the axes
aspect ratio to match that of the image. If *extent* is
not *None*, the axes aspect ratio is changed to match that
of the extent.
If *None*, default to rc ``image.aspect`` value.
*interpolation*:
Acceptable values are *None*, 'none', 'nearest', 'bilinear',
'bicubic', 'spline16', 'spline36', 'hanning', 'hamming',
'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian',
'bessel', 'mitchell', 'sinc', 'lanczos'
If *interpolation* is *None*, default to rc
``image.interpolation``. See also the *filternorm* and
*filterrad* parameters
If *interpolation* is ``'none'``, then no interpolation is
performed on the Agg, ps and pdf backends. Other backends
will fall back to 'nearest'.
*norm*: [ *None* | Normalize ]
An :class:`matplotlib.colors.Normalize` instance; if
*None*, default is ``normalization()``. This scales
luminance -> 0-1
*norm* is only used for an MxN float array.
*vmin*/*vmax*: [ *None* | scalar ]
Used to scale a luminance image to 0-1. If either is
*None*, the min and max of the luminance values will be
used. Note if *norm* is not *None*, the settings for
*vmin* and *vmax* will be ignored.
*alpha*: scalar
The alpha blending value, between 0 (transparent) and 1 (opaque)
or *None*
*origin*: [ *None* | 'upper' | 'lower' ]
Place the [0,0] index of the array in the upper left or lower left
corner of the axes. If *None*, default to rc ``image.origin``.
*extent*: [ *None* | scalars (left, right, bottom, top) ]
Data limits for the axes. The default assigns zero-based row,
column indices to the *x*, *y* centers of the pixels.
*shape*: [ *None* | scalars (columns, rows) ]
For raw buffer images
*filternorm*:
A parameter for the antigrain image resize filter. From the
antigrain documentation, if *filternorm* = 1, 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*:
The filter radius for filters that have a radius
parameter, i.e. when interpolation is one of: 'sinc',
'lanczos' or 'blackman'
Additional kwargs are :class:`~matplotlib.artist.Artist` properties:
%(Artist)s
**Example:**
.. plot:: mpl_examples/pylab_examples/image_demo.py
s image.aspectt
filternormt filterradt resamplec s � j j | � S( N( R� R� ( R� ( R2 ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s N( R� R� R R R� R: R� t set_dataR0 R R� RT RN R4 R5 t set_urlt
set_extentt
get_extentR� R{ R� ( R2 R� R6 R7 Rj t
interpolationR� R8 R9 t originR] R] R� R� t imlimR� t urlRI R� ( ( R2 s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt imshow: s. p
c G s� t | � d k r` | d } | j \ } } t j t j | d � t j | d � � \ } } n: t | � d k r� | \ } } } n t d | | f � � | j d } | j d } t | j � d k s� | j d d k r| j d | � }
|
j | d d �} n t | j � d k s.| j d d k rX| j | d � } | j | d d �} n | j | j k r�t d | | f � � n | | | f S( Ni i i s% Illegal arguments to %s; see help(%s)i����i R� s, Incompatible X, Y inputs to %s; see help(%s)( Rt R] R[ t meshgridRv RN t reshapeRT ( R2 t funcnameRH R� t numRowst numColsR� R R? t NyR` Ra ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _pcolorargs� s*
5
((c -
O s, | j s | j � n | j d d � } | j d d � } | j d d � } | j d d � } | j d d � } | j d d � } | j d | � \ } }
} | j \ } }
t j | � } t j | � } t j |
� }
t j | � t j |
� } | d d
� d d
� f | d d � d d � f | d d
� d d � f | d d � d d
� f } t j | � d | d � d |
d � f | } t j
} t j } | d k j � } | | t j
| d d
� d d
� f � j � � } | | t j
|
d d
� d d
� f � j � � } | | t j
| d d � d d
� f � j � � } | | t j
|
d d � d d
� f � j � � } | | t j
| d d � d d � f � j � � } | | t j
|
d d � d d � f � j � � } | | t j
| d d
� d d � f � j � � } | | t j
|
d d
� d d � f � j � � } t | � } t j | d d � | f | d d � | f | d d � | f | d d � | f | d d � | f | d d � | f | d d � | f | d d � | f | d d � | f | d d � | f f
d
d �} | j | d d f � } | | t j
| d | d � d |
d � f � j � � } d } d | k r�| j d � | d <n | j d | � | d k r�d } n d } d | k r�| j d � | d <n | j d | � } d | k r0| j d � | d <n d | k rgt | � rg| j � d k rgt | d <n t j | | � }! |! j | � |! j | � | d k r�n |! j | � |! j | � |! j | | � |! j � | j t � | j � }" |
j � }# |! j }$ t |$ t! j" � r;t# |$ d � r;|$ j$ | j% � }$ n |$ r�t& |$ j' | j( � � r�|$ | j( }% t j) |" |# g � j* j+ t j, � }& |% j- |& � }' |' d }" |' d }# n t j. |" � }( t j/ |" � }) t j. |# � }* t j/ |# � }+ |( |* f |) |+ f f }, | j0 |, � | j1 � | j2 |! � |! S( s�
Create a pseudocolor plot of a 2-D array.
Note: pcolor can be very slow for large arrays; consider
using the similar but much faster
:func:`~matplotlib.pyplot.pcolormesh` instead.
Call signatures::
pcolor(C, **kwargs)
pcolor(X, Y, C, **kwargs)
*C* is the array of color values.
*X* and *Y*, if given, specify the (*x*, *y*) coordinates of
the colored quadrilaterals; the quadrilateral for C[i,j] has
corners at::
(X[i, j], Y[i, j]),
(X[i, j+1], Y[i, j+1]),
(X[i+1, j], Y[i+1, j]),
(X[i+1, j+1], Y[i+1, j+1]).
Ideally the dimensions of *X* and *Y* should be one greater
than those of *C*; if the dimensions are the same, then the
last row and column of *C* will be ignored.
Note that the the column index corresponds to the
*x*-coordinate, and the row index corresponds to *y*; for
details, see the :ref:`Grid Orientation
<axes-pcolor-grid-orientation>` section below.
If either or both of *X* and *Y* are 1-D arrays or column vectors,
they will be expanded as needed into the appropriate 2-D arrays,
making a rectangular grid.
*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.
Keyword arguments:
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance. If *None*, use
rc settings.
*norm*: [ *None* | Normalize ]
An :class:`matplotlib.colors.Normalize` instance is used
to scale luminance data to 0,1. If *None*, defaults to
:func:`normalize`.
*vmin*/*vmax*: [ *None* | scalar ]
*vmin* and *vmax* are used in conjunction with *norm* to
normalize luminance data. If either is *None*, it
is autoscaled to the respective min or max
of the color array *C*. If not *None*, *vmin* or
*vmax* passed in here override any pre-existing values
supplied in the *norm* instance.
*shading*: [ 'flat' | 'faceted' ]
If 'faceted', a black grid is drawn around each rectangle; if
'flat', edges are not drawn. Default is 'flat', contrary to
MATLAB.
This kwarg is deprecated; please use 'edgecolors' instead:
* shading='flat' -- edgecolors='none'
* shading='faceted -- edgecolors='k'
*edgecolors*: [ *None* | ``'none'`` | color | color sequence]
If *None*, the rc setting is used by default.
If ``'none'``, edges will not be visible.
An mpl color or sequence of colors will set the edge color
*alpha*: ``0 <= scalar <= 1`` or *None*
the alpha blending value
Return value is a :class:`matplotlib.collections.Collection`
instance.
.. _axes-pcolor-grid-orientation:
The grid orientation follows the MATLAB convention: an
array *C* with shape (*nrows*, *ncolumns*) is plotted with
the column number as *X* and the row number as *Y*, increasing
up; hence it is plotted the way the array would be printed,
except that the *Y* axis is reversed. That is, *C* is taken
as *C*(*y*, *x*).
Similarly for :func:`meshgrid`::
x = np.arange(5)
y = np.arange(3)
X, Y = meshgrid(x,y)
is equivalent to::
X = array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
Y = array([[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2]])
so if you have::
C = rand( len(x), len(y))
then you need::
pcolor(X, Y, C.T)
or::
pcolor(C.T)
MATLAB :func:`pcolor` always discards the last row and column
of *C*, but matplotlib displays the last row and column if *X* and
*Y* are not specified, or if *X* and *Y* have one more row and
column than *C*.
kwargs can be used to control the
:class:`~matplotlib.collections.PolyCollection` properties:
%(PolyCollection)s
Note: 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
rcParams['patch.antialiased'], which defaults to *True*.
Stroking the edges may be preferred if *alpha* is 1, but
will cause artifacts otherwise.
.. seealso::
:func:`~matplotlib.pyplot.pcolormesh`
For an explanation of the differences between
pcolor and pcolormesh.
R� R7 R6 R8 R9 t shadingt flatt pcolori i����i NR� i i g �?RV R& R: R} R" RU R% t antialiasedt antialiasedst _as_mpl_transform.( g �?( R} ( .i ( .i (3 R� R� RC R R� R] R R� t getmaskarrayR[ R_ R� R� t filledRt t concatenateR� R: R R� R
R RV R0 R1 R2 R3 R4 R5 R� t
compressedt
_transformR� R� t TransformRM R� R/ R� R� R� t vstackR R� Rw R� Rg Rh R� R� R� (- R2 RH RI R� R7 R6 R8 R9 R� R� R R� R� R? R, t xymaskR_ R� t ravelmaskt X1t Y1t X2t Y2t X3t Y3t X4t Y4t npolyRb R� R& R% t ecR� R` Ra RN R� t ptst transformed_ptsR R R R R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � s� �
j1 44444444 ,&&&, <
$
c O sF | j s | j � n | j d d � } | j d d � } | j d d � } | j d d � } | j d d � } | j d d � j � } | j d t � } | j d d
� | j d | � \ }
} } |
j \ }
} | d k rt j
| d
|
d � d
| d � f � } n | j
� } |
j
� }
| j
� } t j | |
d f d t
�} |
| d d � d
f <| | d d � d f <t j | d |
d | d | d | | �} | j | � | j | � | d k r�n | j | � | j | � | j | | � | j � | j t � | j } t | t j � rUt | d � rU| j | j � } n | r�t | j | j � � r�| | j } t j! |
| g � j" j# t j
� } | j$ | � } | d }
| d } n t j% |
� } t j& |
� } t j% | � } t j& | � } | | f | | f f } | j' | � | j( � | j) | � | S( s�
Plot a quadrilateral mesh.
Call signatures::
pcolormesh(C)
pcolormesh(X, Y, C)
pcolormesh(C, **kwargs)
Create a pseudocolor plot of a 2-D array.
pcolormesh is similar to :func:`~matplotlib.pyplot.pcolor`,
but uses a different mechanism and returns a different
object; pcolor returns a
:class:`~matplotlib.collections.PolyCollection` but pcolormesh
returns a
:class:`~matplotlib.collections.QuadMesh`. It is much faster,
so it is almost always preferred for large arrays.
*C* may be a masked array, but *X* and *Y* may not. Masked
array support is implemented via *cmap* and *norm*; in
contrast, :func:`~matplotlib.pyplot.pcolor` simply does not
draw quadrilaterals with masked colors or vertices.
Keyword arguments:
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance. If *None*, use
rc settings.
*norm*: [ *None* | Normalize ]
A :class:`matplotlib.colors.Normalize` instance is used to
scale luminance data to 0,1. If *None*, defaults to
:func:`normalize`.
*vmin*/*vmax*: [ *None* | scalar ]
*vmin* and *vmax* are used in conjunction with *norm* to
normalize luminance data. If either is *None*, it
is autoscaled to the respective min or max
of the color array *C*. If not *None*, *vmin* or
*vmax* passed in here override any pre-existing values
supplied in the *norm* instance.
*shading*: [ 'flat' | 'gouraud' ]
'flat' indicates a solid color for each quad. When
'gouraud', each quad will be Gouraud shaded. When gouraud
shading, edgecolors is ignored.
*edgecolors*: [ *None* | ``'None'`` | ``'face'`` | color | color sequence]
If *None*, the rc setting is used by default.
If ``'None'``, edges will not be visible.
If ``'face'``, edges will have the same color as the faces.
An mpl color or sequence of colors will set the edge color
*alpha*: ``0 <= scalar <= 1`` or *None*
the alpha blending value
Return value is a :class:`matplotlib.collections.QuadMesh`
object.
kwargs can be used to control the
:class:`matplotlib.collections.QuadMesh` properties:
%(QuadMesh)s
.. seealso::
:func:`~matplotlib.pyplot.pcolor`
For an explanation of the grid orientation and the
expansion of 1-D *X* and/or *Y* to 2-D arrays.
R� R7 R6 R8 R9 R� R� R� R% R t
pcolormesht gouraudi i i Rs NR� .( .i ( .i (* R� R� RC R R� R
R: R� R] R R� R[ R� Rw R t QuadMeshR0 R1 R2 R3 R4 R5 R� R� R� R� R� RM R� R/ R� R� R� R� R R� R� Rg Rh R� R� R� ( R2 RH RI R� R7 R6 R8 R9 R� R� R� R R� R� R? t coordsR� RN R� R� R� R R R R R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� � sf L
0
$
c O s� | j s | j � n | j d d � } | j d d � } | j d d � } | j d d � } | j d d � } | d k r n | d } | j \ } }
t | � d k r� d } d |
g } d | g }
nGt | � d
k r| d \ } }
t j | � } t j |
� }
| j d k r�|
j d k r�| j d k rP|
j d k rPd } qt j
| � } t j
|
� } t j | � d t j | j
� � k r�t j | � d t j | j
� � k r�d } qd
} q| j d k r�|
j d k r�d } qt d � � n t d � � | d k rBt j | � } | j � } |
j � } |
d } | d } t j | | d f t j � } | | d d � d f <| | d d � d f <t j |
| | d d d �} | j | � | j | � | j | � | j | � | j | � | j � | j � | j � | j � f \ } } } } | } n. | d | d |
d |
d f \ } } } } | d k r�t j | | | d d d d d | | | | f | �} | j | � | j | � | j j | � | } n | d
k r7t j! | | |
| d | d | d | | �} | j j | � | } n | j" | � | d k s\| d k ro| j# | | � n
| j$ � | j% t j& | | g | | g g � � | j' d t( � | S( s�
pseudocolor plot of a 2-D array
Experimental; this is a pcolor-type method that
provides the fastest possible rendering with the Agg
backend, and that can handle any quadrilateral grid.
It supports only flat shading (no outlines), it lacks
support for log scaling of the axes, and it does not
have a pyplot wrapper.
Call signatures::
ax.pcolorfast(C, **kwargs)
ax.pcolorfast(xr, yr, C, **kwargs)
ax.pcolorfast(x, y, C, **kwargs)
ax.pcolorfast(X, Y, C, **kwargs)
C is the 2D array of color values corresponding to quadrilateral
cells. Let (nr, nc) be its shape. C may be a masked array.
``ax.pcolorfast(C, **kwargs)`` is equivalent to
``ax.pcolorfast([0,nc], [0,nr], C, **kwargs)``
*xr*, *yr* specify the ranges of *x* and *y* corresponding to the
rectangular region bounding *C*. If::
xr = [x0, x1]
and::
yr = [y0,y1]
then *x* goes from *x0* to *x1* as the second index of *C* goes
from 0 to *nc*, etc. (*x0*, *y0*) is the outermost corner of
cell (0,0), and (*x1*, *y1*) is the outermost corner of cell
(*nr*-1, *nc*-1). All cells are rectangles of the same size.
This is the fastest version.
*x*, *y* are 1D arrays of length *nc* +1 and *nr* +1, respectively,
giving the x and y boundaries of the cells. Hence the cells are
rectangular but the grid may be nonuniform. The speed is
intermediate. (The grid is checked, and if found to be
uniform the fast version is used.)
*X* and *Y* are 2D arrays with shape (*nr* +1, *nc* +1) that specify
the (x,y) coordinates of the corners of the colored
quadrilaterals; the quadrilateral for C[i,j] has corners at
(X[i,j],Y[i,j]), (X[i,j+1],Y[i,j+1]), (X[i+1,j],Y[i+1,j]),
(X[i+1,j+1],Y[i+1,j+1]). The cells need not be rectangular.
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.
Note that the the column index corresponds to the x-coordinate,
and the row index corresponds to y; for details, see
the "Grid Orientation" section below.
Optional keyword arguments:
*cmap*: [ *None* | Colormap ]
A :class:`matplotlib.colors.Colormap` instance from cm. If *None*,
use rc settings.
*norm*: [ *None* | Normalize ]
A :class:`matplotlib.colors.Normalize` instance is used to scale
luminance data to 0,1. If *None*, defaults to normalize()
*vmin*/*vmax*: [ *None* | scalar ]
*vmin* and *vmax* are used in conjunction with norm to normalize
luminance data. If either are *None*, the min and max
of the color array *C* is used. If you pass a norm instance,
*vmin* and *vmax* will be *None*.
*alpha*: ``0 <= scalar <= 1`` or *None*
the alpha blending value
Return value is an image if a regular or rectangular grid
is specified, and a :class:`~matplotlib.collections.QuadMesh`
collection in the general quadrilateral case.
R� R7 R6 R8 R9 i����i R� i i i g{�G�z�?t pcolorimaget quadmeshs' arguments do not match valid signaturess need 1 argument or 3 argumentsNR% R R� t nearestR� R� R] R� () R� R� RC R R] Rt R[ R� R^ R! RY t ptpR� t meanRN R R� RR t float64R R� R0 R1 R2 R3 R� R� Rz R: R� R� R� R{ t PcolorImageR R4 R5 R� R� R� R ( R2 RH RI R� R7 R6 R8 R9 R� R R R\ R` Ra R� R� R� R R? R� R� R� t xlR� t ybR� RJ R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
pcolorfastm s� T
((
6 .
(c O s3 | j s | j � n t | d <t j | | | � S( NR� ( R� R� R
t mcontourt QuadContourSet( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� % s
c O s3 | j s | j � n t | d <t j | | | � S( NR� ( R� R� R R� R� ( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt contourf+ s
c O s | j | | � S( N( t clabel( R2 t CSRH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� 1 s c K s t j | | � S( s�
Add a table to the current axes.
Call signature::
table(cellText=None, cellColours=None,
cellLoc='right', colWidths=None,
rowLabels=None, rowColours=None, rowLoc='left',
colLabels=None, colColours=None, colLoc='center',
loc='bottom', bbox=None):
Returns a :class:`matplotlib.table.Table` instance. For finer
grained control over tables, use the
:class:`~matplotlib.table.Table` class and add it to the axes
with :meth:`~matplotlib.axes.Axes.add_table`.
Thanks to John Gill for providing the class and table.
kwargs control the :class:`~matplotlib.table.Table`
properties:
%(Table)s
( t mtablet table( R2 RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� 5 s c O s% | j j | j t � | | � } | S( sN
make a twinx axes of self. This is used for twinx and twiny.
( R� t add_axesR R ( R2 t klRI t ax2( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt _make_twin_axesP s !c C sf | j d | d t � } | j j � | j j d � | j j d � | j j � | j j t � | S( s�
Call signature::
ax = twinx()
create a twin of Axes for generating a plot with a sharex
x-axis but independent y axis. The y-axis of self will have
ticks on left and the returned axes will have ticks on the
right.
.. note::
For those who are 'picking' artists while using twinx, pick
events are only called for the artists in the top-most axes.
R� R� R� ( R R
RB t
tick_rightt set_label_positiont set_offset_positiont tick_leftRA t set_visible( R2 R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt twinxX s
c C sV | j d | d t � } | j j � | j j d � | j j � | j j t � | S( s�
Call signature::
ax = twiny()
create a twin of Axes for generating a plot with a shared
y-axis but independent x axis. The x-axis of self will have
ticks on bottom and the returned axes will have ticks on the
top.
.. note::
For those who are 'picking' artists while using twiny, pick
events are only called for the artists in the top-most axes.
R� R� R� ( R R
RA t tick_topR t tick_bottomRB R ( R2 R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt twinyp s
c C s | j S( s: Return a copy of the shared axes Grouper object for x axes( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_shared_x_axes� s c C s | j S( s: Return a copy of the shared axes Grouper object for y axes( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_shared_y_axes� s Rr RS R_ c 6 K s� | j s | j � n | } t d } | d2 k rE t d | � � n | d3 k rd t d
| � � n |
d4 k r� t d
|
� � n | j d � d k r� t d � � n | d k r� | r� t } n t | t j
� s� t | d � r�t j | � } | j
d k r| j } n7 | j
d k r;| j d | j d � } n t d � � | j d | j d k r�t j d | j d d d � � q�n" g | D] } t j | � ^ q�} t | � } |
d k r�g t | � D] } | j j j � ^ q�}
n3 t j j |
� }
t |
� | k r#t d � � n | d k r?t | t j
� sRt | d � r�t j | � } | j
d k r|| j } q�| j
d k r�d | j d f | _ q�t d � � n" g | D] } t j | � ^ q�} t | � | k r�t d � � n xS t | � D]5 } t | | � t | | � k rt d � � qqWn
d g | } | j � } | j � } | j t � | j t � | j! j" } t# j | � p�| d k } | st j$ } t j$ } x8 | D]0 } t% | | j% � � } t& | | j& � � } q�W| | f } n t' d | � } t j( d k r3t | d <n g } | } x� t) t | � � D]� } t j* | | | d | | | �\ } } | d k r�t j+ t | � d | j, � } n | r�t j- | � }! | j. t/ � |! | j0 � } n | r�| | 7} | | (n | j1 | � qRW| r�t2 d � }" t# j3 | � rQ| d k rQt2 d d d � }" n | r�g | D]' } | t j- | � |" j4 � |" ^ q^} q�g | D] } | |" j4 � |" ^ q�} n | j5 � g }# | j6 d � r�t j- | � }$ | d k r
t% d t& d | � � }% n! t | � d k r(d }% n d }% | d k r�| r�|% |$ | }& |& }' | d k r~d |% |$ d d | }( n d }( t } n+ | d k s�| r�|% |$ }& d5 \ }( }' n | d k s�| d! k r�|( d" |$ 7}( n | d k r�|( |$ 7}( n |
d k r| j7 }) n | j8 }) x�t9 | |
� D]O \ } }* |) | d |( | |& d# d$ d% | d& |* �}+ |# j1 |+ � |( |' 7}( q+Wn4| j6 d � r�
t j+ d t | � t j/ � } t j+ d t | � t j/ � }, | | | d d d � <| d d d � <t j% | � }- | d k s | d$ k r9| d" | d | d 8} n) | d k rb| d" | d | d 7} n | r�|- |- |, d <|, d <|
d k r�| j: d% � q�| j; d% � n | d k }. x� t9 | |
� D]� \ } }* | | |, d d d � <|, d d d � <| r |- |, |, |- k <n |
d k r- |, | } }, n |. r[ |# j1 | j< | |, d' t d( |* �� q�|# j1 | j< | |, d' t d) |* d* t �� q�W|
d k r
t& | d d+ |- � }/ | j! j= d } x' | D] } t j> | | d k � } q� Wt& | d+ |- � } t% |/ | � } | | f | j! _= q�
|
d k r�
t& | d d+ |- � }0 | j! j? d }1 x' | D] } t j> | | d k � }2 qX
Wt& |2 d+ |- � }2 t% |0 |2 � }2 |2 |1 f | j! _? q�
n | d k r�
d g }3 n? t@ | � r�
| g }3 n' tA | � r tB | � }3 n t d, � � t |3 � | k r< |3 d g | t |3 � 7}3 n x� t9 |# |3 � D]� \ }+ }4 |+ rL |+ d }5 |5 jC | � |4 d k r� |5 jD |4 � n |5 jE t � x/ |+ d D] }5 |5 jC | � |5 jD d- � q� WqL qL W| rF |
d k r | jF | d d f | d d f g d. t �qF | jF d | d f d | d f g d/ t �n | j | � | j | � | jG � | d k r� | d | t# jH d0 |# d � f S| | t# jH d1 |# � f Sd S(6 s�
Plot a histogram.
Call signature::
hist(x, bins=10, range=None, normed=False, weights=None,
cumulative=False, bottom=None, histtype='bar', align='mid',
orientation='vertical', rwidth=None, log=False,
color=None, label=None, stacked=False,
**kwargs)
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.
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.
Keyword arguments:
*bins*:
Either an integer number of bins or a sequence giving the
bins. If *bins* is an integer, *bins* + 1 bin edges
will be returned, consistent with :func:`numpy.histogram`
for numpy version >= 1.3, and with the *new* = True argument
in earlier versions.
Unequally spaced bins are supported if *bins* is a sequence.
*range*:
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.
*normed*:
If *True*, the first element of the return tuple will
be the counts normalized to form a probability density, i.e.,
``n/(len(x)*dbin)``. In a probability density, the integral of
the histogram should be 1; you can verify that with a
trapezoidal integration of the probability density function::
pdf, bins, patches = ax.hist(...)
print np.sum(pdf * np.diff(bins))
.. note::
Until numpy release 1.5, the underlying numpy
histogram function was incorrect with *normed*=*True*
if bin sizes were unequal. MPL inherited that
error. It is now corrected within MPL when using
earlier numpy versions
*weights*:
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* is True, the weights are
normalized, so that the integral of the density over the range
remains 1.
*cumulative*:
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*
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* is also *True*, then the histogram is normalized
such that the first bin equals 1.
*histtype*: [ 'bar' | 'barstacked' | 'step' | 'stepfilled' ]
The type of histogram to draw.
- 'bar' is a traditional bar-type histogram. If multiple data
are given the bars are aranged 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.
*align*: ['left' | 'mid' | 'right' ]
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.
*orientation*: [ 'horizontal' | 'vertical' ]
If 'horizontal', :func:`~matplotlib.pyplot.barh` will be
used for bar-type histograms and the *bottom* kwarg will be
the left edges.
*rwidth*:
The relative width of the bars as a fraction of the bin
width. If *None*, automatically compute the width. Ignored
if *histtype* = 'step' or 'stepfilled'.
*log*:
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.
*color*:
Color spec or sequence of color specs, one per
dataset. Default (*None*) uses the standard line
color sequence.
*label*:
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::
ax.hist(10+2*np.random.randn(1000), label='men')
ax.hist(12+3*np.random.randn(1000), label='women', alpha=0.5)
ax.legend()
*stacked*:
If *True*, multiple data are stacked on top of each other
If *False* multiple data are aranged side by side if
histtype is 'bar' or on top of each other if histtype is 'step'
.
kwargs are used to update the properties of the
:class:`~matplotlib.patches.Patch` instances returned by *hist*:
%(Patch)s
**Example:**
.. plot:: mpl_examples/pylab_examples/histogram_demo.py
R� Rr t
barstackedRT t
stepfilleds histtype %s is not recognizedR� RS R� s align kwarg %s is not recognizedRa R_ s& orientation kwarg %s is not recognizedR� sF hist now uses the rwidth to give relative width and not absolute widthi i i s x must be 1D or 2DsX 2D hist input should be nsamples x nvariables;
this looks transposed (shape is %d x %d)Ni����s+ color kwarg must have one color per datasets weights must be 1D or 2Ds' weights should have the same shape as xs 1.3t newt weightsg �?g g�������?g �R] g �?R\ R� R~ R# Rm Rk RU Rl g�������?s4 invalid label: must be string or sequence of stringsRA R� R� R� s Lists of Patches( s barR s stepR ( s lefts mids right( s
horizontals vertical( g g (I R� R� t __builtins__R Rx R R* R R� R[ t ndarrayR� R� R^ R R� R] R( R) Rt Ry R@ R; Rf R R Rd R� R R
R R
R R� R� R) t infR� Rz Ru t __version__t reversedt histogramR� Rs RY R� Rw R� R{ t slicet
is_numliket cumsumt reverseRK Rs Rr Ru R� R� Rl R Rg R! R R) Rc R� R� t set_snapR� R� R� (6 R2 R` R\ R� R; R t
cumulativeR� t histtypeR\ R^ t rwidthR~ R# R� t stackedRI t bin_rangeR� R` Rn R� t wit _saved_autoscalext _saved_autoscaleyt
_saved_boundst binsgivenRu Rv t hist_kwargsRi t mlastR
t dbt slcR� t totwidtht drR� t dwt boffsett _barfuncR% RN Ra Rw Rl t xmin0t ymin0Rx Rw R� t lblR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt hist� sz �
# " + # "
) "
7*
' '
00
!c K s� | }
t d } t j | | d | d |
d | d | �\ } } }
| d k rb d | | | k <n | d k r� d | | | k <n | j | |
| j | � } | j | d | d � | j |
d |
d � | | |
| f S( sJ
Make a 2D histogram plot.
Call signature::
hist2d(x, y, bins = None, range=None, weights=None, cmin=None, cmax=None **kwargs)
Make a 2d histogram plot of *x* versus *y*, where *x*,
*y* are 1-D sequences of the same length.
The return value is ``(counts, xedges, yedges, Image)``.
Optional keyword arguments:
*bins*: [None | int | [int, int] | array_like | [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*: [*None* | array_like shape(2,2)]
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.
*normed*:[True|False]
Normalize histogram.
The default value is False
*weights*: [*None* | array]
An array of values w_i weighing each sample (x_i, y_i).
*cmin* : [None| scalar]
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* : [None| scalar]
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
Remaining keyword arguments are passed directly to :meth:`pcolorfast`.
Rendering the histogram with a logarithmic color scale is
accomplished by passing a :class:`colors.LogNorm` instance to
the *norm* keyword argument.
**Example:**
.. plot:: mpl_examples/pylab_examples/hist2d_demo.py
R� R\ R; R i i����N( R R[ t histogram2dR R� R R. R: ( R2 R` Ra R\ R� R; R t cmint cmaxRI R! R� t xedgest yedgest pc( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt hist2dF s G
i i R� c
K s] | j s | j � n t j | | | | | | | | |
� \ } }
t |
� f | _ |
| 7}
|
d t f k rz d } n d } | j |
d t j
| � | � | j d � | j d | � | j
t � | j j \ } } | | } t t j
| � � } | d k rd } n d | } t j t j | � t j | � d | � } | j | � | |
f S(
s�
Plot the power spectral density.
Call signature::
psd(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,
window=mlab.window_hanning, noverlap=0, pad_to=None,
sides='default', scale_by_freq=None, **kwargs)
The power spectral density 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 *Pxx*, with a
scaling to correct for power loss due to windowing. *Fs* is the
sampling frequency.
%(PSD)s
*noverlap*: integer
The number of points of overlap between blocks. The default value
is 0 (no overlap).
*Fc*: integer
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 the tuple (*Pxx*, *freqs*).
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)
kwargs control the :class:`~matplotlib.lines.Line2D` properties:
%(Line2D)s
**Example:**
.. plot:: mpl_examples/pylab_examples/psd_demo.py
s dB/Hzt dBi
t Frequencys Power Spectral Density (%s)i g�������?i N( R� R� R� t psdRt R] R R R. R[ R| R R R� R� R! R Rv Rs RO t ceilR� ( R2 R` t NFFTt Fst FcR< t windowt noverlapt pad_tot sidest
scale_by_freqRI t pxxt freqst psd_unitsR8 R9 t intvt logiRT R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR= � s, 4
+
c K s) | j s | j � n t j | | | | | | | | |
| �
\ }
} t | � f |
_ | | 7} | j | d t j t j |
� � | � | j
d � | j d � | j t
� | j j \ } } | | } d t t j | � � } t j t j | � t j | � d | � } | j | � |
| f S( s�
Plot cross-spectral density.
Call signature::
csd(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,
window=mlab.window_hanning, noverlap=0, pad_to=None,
sides='default', scale_by_freq=None, **kwargs)
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*. 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.
Returns the tuple (*Pxy*, *freqs*). *P* is the cross spectrum
(complex valued), and :math:`10\log_{10}|P_{xy}|` is
plotted.
%(PSD)s
*noverlap*: integer
The number of points of overlap between blocks. The
default value is 0 (no overlap).
*Fc*: integer
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.
References:
Bendat & Piersol -- Random Data: Analysis and Measurement
Procedures, John Wiley & Sons (1986)
kwargs control the Line2D properties:
%(Line2D)s
**Example:**
.. plot:: mpl_examples/pylab_examples/csd_demo.py
.. seealso:
:meth:`psd`
For a description of the optional parameters.
i
R< s Cross Spectrum Magnitude (dB)i ( R� R� R� t csdRt R] R. R[ R| t absoluteR R R� R R� R! R Rv Rs RO R> R� ( R2 R` Ra R? R@ RA R< RB RC RD RE RF RI t pxyRH R8 R9 RJ RT R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRL � s 6
)
+
c K s� | j s | j � n t j | | | | | | | | � \ }
} | | 7} | j | |
| � | j d � | j d � | j t � |
| f S( s}
Plot the coherence between *x* and *y*.
Call signature::
cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend = mlab.detrend_none,
window = mlab.window_hanning, noverlap=0, pad_to=None,
sides='default', scale_by_freq=None, **kwargs)
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}}
%(PSD)s
*noverlap*: integer
The number of points of overlap between blocks. The
default value is 0 (no overlap).
*Fc*: integer
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.
The return value is a tuple (*Cxy*, *f*), where *f* are the
frequencies of the coherence vector.
kwargs are applied to the lines.
References:
* Bendat & Piersol -- Random Data: Analysis and Measurement
Procedures, John Wiley & Sons (1986)
kwargs control the :class:`~matplotlib.lines.Line2D`
properties of the coherence plot:
%(Line2D)s
**Example:**
.. plot:: mpl_examples/pylab_examples/cohere_demo.py
R< t Coherence( R� R� R� t cohereR. R R R� R ( R2 R` Ra R? R@ RA R< RB RC RD RE RF RI t cxyRH ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRP 4! s 3
i� c
K s� | j s | j � n t j | | | | | | |
| | � \ } } } d t j | � } t j | � } | d k r� d t j | � f } n | \ } } | | 7} | | | d | d f } | j | | d | |
�} | j
d � | | | | f S( sl
Plot a spectrogram.
Call signature::
specgram(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,
window=mlab.window_hanning, noverlap=128,
cmap=None, xextent=None, pad_to=None, sides='default',
scale_by_freq=None, **kwargs)
Compute a spectrogram of data in *x*. Data are split into
*NFFT* length segments and the PSD 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*.
%(PSD)s
*noverlap*: integer
The number of points of overlap between blocks. The
default value is 128.
*Fc*: integer
The center frequency of *x* (defaults to 0), which offsets
the y 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*:
The image extent along the x-axis. xextent = (xmin,xmax)
The default is (0,max(bins)), where bins is the return
value from :func:`~matplotlib.mlab.specgram`
*kwargs*:
Additional kwargs are passed on to imshow which makes the
specgram image
Return value is (*Pxx*, *freqs*, *bins*, *im*):
- *bins* are the time points the spectrogram is calculated over
- *freqs* is an array of frequencies
- *Pxx* is an array of shape `(len(times), len(freqs))` of power
- *im* is a :class:`~matplotlib.image.AxesImage` instance
Note: If *x* is real (i.e. non-complex), only the positive
spectrum is shown. If *x* is complex, both positive and
negative parts of the spectrum are shown. This can be
overridden using the *sides* keyword argument.
**Example:**
.. plot:: mpl_examples/pylab_examples/specgram_demo.py
g $@i i����R] R� N( R� R� R� t specgramR[ R| t flipudR Rh R� R� ( R2 R` R? R@ RA R< RB RC R6 t xextentRD RE RF RI t PxxRH R\ t ZRu Rv R] R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRR s! s ?
Rh c K s | d% k r" d } t j d � n | d% k rR | d% k rR t | d � rR d } n | d% k r| d% k rt j | � } t j | � | k } d | k r� t j d d g d d �| d <n | j \ } } d
| d | d d
g }
| j
| d d
d | d |
d d | �} n^t | d � r�| j � } | d k rN| j }
| j
} q�t j | j � | k } | j | }
| j
| } n9 t j | � } t j | � | k } t j | � \ }
} | d% k r�d } n | d% k r�d } n t j | |
d d d | d | | �} | j | � | j \ } } | j d d
d | d � | j d | d d d
� | j | � | } | j j d � | j j � | j j d � | j j t j d d d d! d" d# d g d$ t � � | j j t j d d d d! d" d# d g d$ t � � | S(& s7
Plot the sparsity pattern on a 2-D array.
Call signature::
spy(Z, precision=0, marker=None, markersize=None,
aspect='equal', **kwargs)
``spy(Z)`` plots the sparsity pattern of the 2-D array *Z*.
If *precision* is 0, any non-zero value will be plotted;
else, values of :math:`|Z| > precision` will be plotted.
For :class:`scipy.sparse.spmatrix` instances, there is a
special case: if *precision* is 'present', any value present in
the array will be plotted, even if it is identically zero.
The array will be plotted as it would be printed, with
the first index (row) increasing down and the second
index (column) increasing to the right.
By default aspect is 'equal', so that each array element
occupies a square space; set the aspect kwarg to 'auto'
to allow the plot to fill the plot box, or to any scalar
number to specify the aspect ratio of an array element
directly.
Two plotting styles are available: image or marker. Both
are available for full arrays, but only the marker style
works for :class:`scipy.sparse.spmatrix` instances.
If *marker* and *markersize* are *None*, an image will be
returned and any remaining kwargs are passed to
:func:`~matplotlib.pyplot.imshow`; else, a
:class:`~matplotlib.lines.Line2D` object will be returned with
the value of marker determining the marker type, and any
remaining kwargs passed to the
:meth:`~matplotlib.axes.Axes.plot` method.
If *marker* and *markersize* are *None*, useful kwargs include:
* *cmap*
* *alpha*
.. seealso::
:func:`~matplotlib.pyplot.imshow`
For image options.
For controlling colors, e.g. cyan background and red marks,
use::
cmap = mcolors.ListedColormap(['c','r'])
If *marker* or *markersize* is not *None*, useful kwargs include:
* *marker*
* *markersize*
* *color*
Useful values for *marker* include:
* 's' square (default)
* 'o' circle
* '.' point
* ',' pixel
.. seealso::
:func:`~matplotlib.pyplot.plot`
For plotting options
i s Use precision=0 instead of Nonet tocooR R6 R� R} RE t binaryg �g �?R� R� Rj R] R� R~ t presenti
R! R R" t
markersizeRu Rv Rw Rx g�������?R
t nbinsi t stepsi i i t integerN( R R( R* RM R[ R� RM R t ListedColormapR] R� RW R Rw R� t nonzeroR Rg R� R. R: R� RL t set_yRA R t set_ticks_positionR7 t mtickert MaxNLocatorR RB ( R2 RV t precisionR" RZ Rj RI R, R R R] RJ R% Ra R` R_ t marks( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt spy�! s` J '
c K s� t j | � } | j \ } } i d d 6d d 6d d 6} | j | � | j | | � } | j j d � | j j � | j j d � | j j
t j d d
d d d
d d g d t
� � | j j
t j d d
d d d
d d g d t
� � | S( s
Plot a matrix or array as an 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.
Argument:
*Z* anything that can be interpreted as a 2-D array
kwargs all are passed to :meth:`~matplotlib.axes.Axes.imshow`.
:meth:`matshow` sets defaults for *origin*,
*interpolation*, and *aspect*; if you want row zero to
be at the bottom instead of the top, you can set the *origin*
kwarg to "lower".
Returns: an :class:`matplotlib.image.AxesImage` instance.
R~ R� R� R� Rh Rj g�������?R
R[ i R\ i i i i
R] ( R[ R* R] R� R� RL R` RA R Ra R7 Rb Rc R RB ( R2 RV RI R R Rh R� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt matshowA" s"
c C sH g | j D] } | j � r
| ^ q
} | j rD | j | j � n | S( N( R� R+ RE R{ ( R2 RN t bbox_extra_artists( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt get_default_bbox_extra_artistsf" s ( c C s5 g } g } | j � s d S| j � } | rS | rS | | | � } | j | � n
| j � | j | j | � � | j j � r� | j | j j | � � n | j j | � } | r� | j | � n | j j | � } | r� | j | � n t
j j g | D]* } | j
d k s"| j d k r� | ^ q� � }
|
S( s�
Return the tight bounding box of the axes.
The dimension of the Bbox in canvas coordinate.
If *call_axes_locator* is *False*, it does not call the
_axes_locator attribute, which is necessary to get the correct
bounding box. ``call_axes_locator==False`` can be used if the
caller is only intereted in the relative size of the tightbbox
compared to the axes bbox.
i N( R+ R R R� R{ R� RL RA t
get_tightbboxRB R� R� R� R� R� ( R2 RD t call_axes_locatorRC R% R R
t bb_xaxist bb_yaxisRc t _bbox( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRj m" s(
Cc C sq xj | j | j f D]V } | j � d k rV | j } | j t j | j | j � � q | j t j � � q Wd S( s( Add autoscaling minor ticks to the axes.R~ N(
RA RB R4 t _scaleR8 Rb t
LogLocatort baset subst AutoMinorLocator( R2 R# R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
minorticks_on�" s
"c C s0 | j j t j � � | j j t j � � d S( s! Remove minor ticks from the axes.N( RA R8 Rb t NullLocatorRB ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt minorticks_off�" s c O s t j | | | � S( N( t mtrit
tricontour( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRx �" s c O s t j | | | � S( N( Rw t tricontourf( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRy �" s c O s t j | | | � S( N( Rw t tripcolor( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRz �" s c O s t j | | | � d S( N( Rw t triplot( R2 RH RI ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR{ �" s ( R� R� R� RE R) t GrouperR� R� R� R R R3 R8 R� R� R� R� R� R� R� R R R R� R
R R R R� R R R R� R� R` t propertyt frameRa R1 Rb Rd Rf R� Rm Ri Ro 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� R� R� R� R� R R R R R R
R� R R R R R R R R R� R R5 RP RQ RR t _Axes__draw_animateRX RY RZ R[ R t dedent_interpdR� Rl Rp Ry R� R� Rz R{ R| R} Rq R� R- R. R R� R� R� R� R� R� R� R� R� R� R� R� Rr R� R9 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� R� R� R� R R� R� t _Axes__pickR� R� R� R R R R" R R R
R R t dedentR R$ R. R( R0 R2 R3 R5 R� t detrend_noneR4 RJ RM RO RT Rr Rs Rx R� R� Rf R! R? R[ R� R R� R� R� R� t
quiverkey_docR� R� t
quiver_docR� R� R� R� R� Rl R� R� R� R� R� R� R� R� R� R� t contour_docR� R� R� R� R R R R R
R3 R: t window_hanningR= RL RP RR Rf Rg Ri Rj Rt Rv Rx Rw t
TriContourSett tricontour_docRy Rz R{ ( ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� X s|
( ! u
6
� G
+
*
: *?v
' X' L
X Y
G
E Q??78WP�G<33? W � "� H- 4 � � 8 � X � � �
2�m � ��� � � S K H < L } % ( ( t GridSpect SubplotSpect SubplotBasec B s� e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z RS( s�
Base class for subplots, which are :class:`Axes` instances with
additional methods to facilitate generating and manipulating a set
of :class:`Axes` within a figure.
c O s� | | _ t | � d k r� t | d t � r> | d | _ q�y2 t t | d � � } t t | � \ } } } Wn t k
r� t d � � n Xt | | � | d | _ n� t | � d k rq| \ } } } t | � } t | � } t | t
� rNt | � d k rNg | D] } t | � ^ q} t | | � | d d | d !| _ q�t | | � t | � d | _ n t d | f � � | j � | j j
| | | j | � d S( s
*fig* is a :class:`matplotlib.figure.Figure` instance.
*args* is the tuple (*numRows*, *numCols*, *plotNum*), where
the array of subplots in the figure has dimensions *numRows*,
*numCols*, and where *plotNum* is the number of the subplot
being created. *plotNum* starts at 1 in the upper left
corner and increases to the right.
If *numRows* <= *numCols* <= *plotNum* < 10, *args* can be the
decimal integer *numRows* * 100 + *numCols* * 10 + *plotNum*.
i i s4 Single argument to subplot must be a 3-digit integeri i s" Illegal argument(s) to subplot: %sN( R� Rt R� R� t _subplotspecR R t mapR R� R� t
update_paramst _axes_classR3 t figbox( R2 R� RH RI R t rowst colst numRi ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR3 �" s,
! (#
c C s` d � } g | j j � D] } | | � r | ^ q d } t � | f | j � g } t | � S( Nc S s t | t � o t | t � S( N( t
issubclassR� R� ( R% ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� �" s i ( t __class__t mrot! _PicklableSubplotClassConstructorR4 R� ( R2 t not_subplotbaseR% t
axes_classRM ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt
__reduce__�" s 2c C s/ | j � j � \ } } } } | | | d f S( s" get the subplot geometry, eg 2,2,3i ( t get_subplotspect get_geometry( R2 R� R� t num1t num2( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� �" s c C s8 t | | � | d | _ | j � | j | j � d S( s0 change subplot geometry, eg. from 1,1,1 to 2,2,3i N( R� R� R� R R� ( R2 t numrowst numcolsR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt change_geometry�" s
c C s | j S( s8 get the SubplotSpec instance associated with the subplot( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� # s c C s
| | _ d S( s8 set the SubplotSpec instance associated with the subplotN( R� ( R2 t subplotspec( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt set_subplotspec# s c C s@ | j � j | j d t �\ | _ | _ | _ | _ | _ d S( s0 update the subplot position from fig.subplotparst
return_allN( R� R R� R R� t rowNumt colNumR� R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR�
# s c C s
| j d k S( Ni ( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt is_first_col# s c C s
| j d k S( Ni ( R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt is_first_row# s c C s | j | j d k S( Ni ( R� R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt is_last_row# s c C s | j | j d k S( Ni ( R� R� ( R2 ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt is_last_col # s c C sd | j � } | j � } x! | j � D] } | j | � q% Wx! | j � D] } | j | � qI Wd S( s�
set the visible property on ticklabels so xticklabels are
visible only if the subplot is in the last row and yticklabels
are visible only if the subplot is in the first column
N( R� R� R� R R� ( R2 t lastrowt firstcolR� ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt label_outer # s c O s" | j j | j � | | � } | S( sN
make a twinx axes of self. This is used for twinx and twiny.
( R� t add_subplotR� ( R2 R RI R ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR /# s ( R� R� R� R3 R� R� R� R� R� R� R� R� R� R� R� R ( ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� �" s /
c C sg | d k r t } n t j | � } | d k rc t d | j t | f i | d 6� } | t | <n | S( Ns %sSubplotR� ( R R� t _subplot_classesRx t typeR� R� ( R� t new_class( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt subplot_class_factory8# s
R� c B s e Z d Z d � Z RS( s�
This stub class exists to return the appropriate subplot
class when __call__-ed with an axes class. This is purely to
allow Pickling of Axes and Subplots.
c C s" t � } t | � } | | _ | S( N( R� R� R� ( R2 R� t subplot_instancet
subplot_class( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyRK T# s ( R� R� R� RK ( ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyR� N# s t Subplot(s t
__future__R R Rs t sysR( t datetimet operatorR R9 t numpyR[ R R� R t matplotlib.artistR� R� R t matplotlib.axisR� R� t matplotlib.cbookR) t matplotlib.collectionsR� R t matplotlib.colorsR R t matplotlib.contourR� R� t matplotlib.datest datesR� R t matplotlib.font_managerRG t matplotlib.imageR� R: t matplotlib.legendRO RB t matplotlib.linesR� R t matplotlib.markerst markersR, t matplotlib.mlabR� t matplotlib.pathR� R� t matplotlib.patchesR� Ro t matplotlib.spinesR� R t matplotlib.quiverR� R� t matplotlib.scaleR� R� t matplotlib.stackplotR� R� t matplotlib.streamplotR� R� t matplotlib.tableR� R� t matplotlib.textR" RJ t matplotlib.tickert tickerRb t matplotlib.transformst
transformsR� t matplotlib.trit triRw t matplotlib.containerR R R R� R R) R R' R, RS R- R� R� t matplotlib.gridspecR� R� R� R� R R� R� R� t interpdR� t kwdoc( ( ( s5 /usr/lib64/python2.7/site-packages/matplotlib/axes.pyt <module> s� 0 S �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � }�