Menu
▾
▴
[r3311]: / trunk / htdocs / matplotlib.pylab.html.template Maximize Restore History
3349 lines (3346 with data), 327.0 kB
@header@
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"> <br><big><big><strong><a href="matplotlib.html"><font color="#ffffff">matplotlib</font></a>.pylab</strong></big></big></font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/jdhunter/dev/lib/python2.5/site-packages/matplotlib/pylab.py">/home/jdhunter/dev/lib/python2.5/site-packages/matplotlib/pylab.py</a></font></td></tr></table>
<p><tt>This is a matlab(TM) style interface to matplotlib.<br>
<br>
The following plotting commands are provided; some of these do not<br>
exist in matlab(TM) but have proven themselves to be useful nonetheless.<br>
The majority of them, however, have matlab analogs<br>
<br>
_Plotting commands<br>
acorr - plot the autocorrelation function<br>
annotate - annotate something in the figure<br>
arrow - add an arrow to the axes<br>
axes - Create a new axes<br>
axhline - draw a horizontal line across axes<br>
axvline - draw a vertical line across axes<br>
axhspan - draw a horizontal bar across axes<br>
axvspan - draw a vertical bar across axes<br>
axis - Set or return the current axis limits<br>
bar - make a bar chart<br>
barh - a horizontal bar chart<br>
broken_barh - a set of horizontal bars with gaps<br>
box - set the axes frame on/off state<br>
boxplot - make a box and whisker plot<br>
cla - clear current axes<br>
clabel - label a contour plot<br>
clf - clear a figure window<br>
clim - adjust the color limits of the current image<br>
close - close a figure window<br>
colorbar - add a colorbar to the current figure<br>
cohere - make a plot of coherence<br>
contour - make a contour plot<br>
contourf - make a filled contour plot<br>
csd - make a plot of cross spectral density<br>
delaxes - delete an axes from the current figure<br>
draw - Force a redraw of the current figure<br>
errorbar - make an errorbar graph<br>
figlegend - make legend on the figure rather than the axes<br>
figimage - make a figure image<br>
figtext - add text in figure coords<br>
figure - create or change active figure<br>
fill - make filled polygons<br>
gca - return the current axes<br>
gcf - return the current figure<br>
gci - get the current image, or None<br>
getp - get a handle graphics property<br>
grid - set whether gridding is on<br>
hist - make a histogram<br>
hold - set the axes hold state<br>
ioff - turn interaction mode off<br>
ion - turn interaction mode on<br>
isinteractive - return True if interaction mode is on<br>
imread - load image file into array<br>
imshow - plot image data<br>
ishold - return the hold state of the current axes<br>
legend - make an axes legend<br>
loglog - a log log plot<br>
matshow - display a matrix in a new figure preserving aspect<br>
pcolor - make a pseudocolor plot<br>
pcolormesh - make a pseudocolor plot using a quadrilateral mesh<br>
pie - make a pie chart<br>
plot - make a line plot<br>
plot_date - plot dates<br>
pie - pie charts<br>
polar - make a polar plot on a PolarAxes<br>
psd - make a plot of power spectral density<br>
quiver - make a direction field (arrows) plot<br>
rc - control the default params<br>
rgrids - customize the radial grids and labels for polar<br>
savefig - save the current figure<br>
scatter - make a scatter plot<br>
setp - set a handle graphics property<br>
semilogx - log x axis<br>
semilogy - log y axis<br>
show - show the figures<br>
specgram - a spectrogram plot<br>
spy - plot sparsity pattern using markers or image<br>
stem - make a stem plot<br>
subplot - make a subplot (numrows, numcols, axesnum)<br>
subplots_adjust - change the params controlling the subplot positions of current figure<br>
subplot_tool - launch the subplot configuration tool<br>
table - add a table to the plot<br>
text - add some text at location x,y to the current axes<br>
thetagrids - customize the radial theta grids and labels for polar<br>
title - add a title to the current axes<br>
xcorr - plot the autocorrelation function of x and y<br>
xlim - set/get the xlimits<br>
ylim - set/get the ylimits<br>
xticks - set/get the xticks<br>
yticks - set/get the yticks<br>
xlabel - add an xlabel to the current axes<br>
ylabel - add a ylabel to the current axes<br>
<br>
autumn - set the default colormap to autumn<br>
bone - set the default colormap to bone<br>
cool - set the default colormap to cool<br>
copper - set the default colormap to copper<br>
flag - set the default colormap to flag<br>
gray - set the default colormap to gray<br>
hot - set the default colormap to hot<br>
hsv - set the default colormap to hsv<br>
jet - set the default colormap to jet<br>
pink - set the default colormap to pink<br>
prism - set the default colormap to prism<br>
spring - set the default colormap to spring<br>
summer - set the default colormap to summer<br>
winter - set the default colormap to winter<br>
spectral - set the default colormap to spectral<br>
<br>
_Event handling<br>
<br>
connect - register an event handler<br>
disconnect - remove a connected event handler<br>
<br>
_Matrix commands<br>
<br>
cumprod - the cumulative product along a dimension<br>
cumsum - the cumulative sum along a dimension<br>
detrend - remove the mean or besdt fit line from an array<br>
diag - the k-th diagonal of matrix<br>
diff - the n-th differnce of an array<br>
eig - the eigenvalues and eigen vectors of v<br>
eye - a matrix where the k-th diagonal is ones, else zero<br>
find - return the indices where a condition is nonzero<br>
fliplr - flip the rows of a matrix up/down<br>
flipud - flip the columns of a matrix left/right<br>
linspace - a linear spaced vector of N values from min to max inclusive<br>
meshgrid - repeat x and y to make regular matrices<br>
ones - an array of ones<br>
rand - an array from the uniform distribution [0,1]<br>
randn - an array from the normal distribution<br>
rot90 - rotate matrix k*90 degress counterclockwise<br>
squeeze - squeeze an array removing any dimensions of length 1<br>
tri - a triangular matrix<br>
tril - a lower triangular matrix<br>
triu - an upper triangular matrix<br>
vander - the Vandermonde matrix of vector x<br>
svd - singular value decomposition<br>
zeros - a matrix of zeros<br>
<br>
_Probability<br>
<br>
levypdf - The levy probability density function from the char. func.<br>
normpdf - The Gaussian probability density function<br>
rand - random numbers from the uniform distribution<br>
randn - random numbers from the normal distribution<br>
<br>
_Statistics<br>
<br>
corrcoef - correlation coefficient<br>
cov - covariance matrix<br>
amax - the maximum along dimension m<br>
mean - the mean along dimension m<br>
median - the median along dimension m<br>
amin - the minimum along dimension m<br>
norm - the norm of vector x<br>
prod - the product along dimension m<br>
ptp - the max-min along dimension m<br>
std - the standard deviation along dimension m<br>
asum - the sum along dimension m<br>
<br>
_Time series analysis<br>
<br>
bartlett - M-point Bartlett window<br>
blackman - M-point Blackman window<br>
cohere - the coherence using average periodiogram<br>
csd - the cross spectral density using average periodiogram<br>
fft - the fast Fourier transform of vector x<br>
hamming - M-point Hamming window<br>
hanning - M-point Hanning window<br>
hist - compute the histogram of x<br>
kaiser - M length Kaiser window<br>
psd - the power spectral density using average periodiogram<br>
sinc - the sinc function of array x<br>
<br>
_Dates<br>
<br>
date2num - convert python datetimes to numeric representation<br>
drange - create an array of numbers for date plots<br>
num2date - convert numeric type (float days since 0001) to datetime<br>
<br>
_Other<br>
<br>
angle - the angle of a complex array<br>
load - load ASCII data into array<br>
polyfit - fit x, y to an n-th order polynomial<br>
polyval - evaluate an n-th order polynomial<br>
roots - the roots of the polynomial coefficients in p<br>
save - save an array to an ASCII file<br>
trapz - trapezoidal integration<br>
<br>
__end<br>
<br>
Credits: The plotting commands were provided by<br>
John D. Hunter <jdhunter@ace.bsd.uchicago.edu><br>
<br>
Most of the other commands are from Numeric, MLab and FFT, with the<br>
exception of those in mlab.py provided by matplotlib.</tt></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#aa55cc">
<td colspan=3 valign=bottom> <br>
<font color="#fffff" face="helvetica, arial"><big><strong>Modules</strong></big></font></td></tr>
<tr><td bgcolor="#aa55cc"><tt> </tt></td><td> </td>
<td width="100%"><table width="100%" summary="list"><tr><td width="25%" valign=top><a href="numpy.oldnumeric.linear_algebra.html">numpy.oldnumeric.linear_algebra</a><br>
<a href="numpy.oldnumeric.random_array.html">numpy.oldnumeric.random_array</a><br>
<a href="StringIO.html">StringIO</a><br>
<a href="matplotlib._pylab_helpers.html">matplotlib._pylab_helpers</a><br>
<a href="matplotlib.backends.html">matplotlib.backends</a><br>
<a href="matplotlib.cm.html">matplotlib.cm</a><br>
</td><td width="25%" valign=top><a href="copy.html">copy</a><br>
<a href="copy_reg.html">copy_reg</a><br>
<a href="matplotlib.dates.html">matplotlib.dates</a><br>
<a href="matplotlib.image.html">matplotlib.image</a><br>
<a href="math.html">math</a><br>
<a href="matplotlib.html">matplotlib</a><br>
</td><td width="25%" valign=top><a href="matplotlib.mlab.html">matplotlib.mlab</a><br>
<a href="numpy.core.multiarray.html">numpy.core.multiarray</a><br>
<a href="matplotlib.numerix.html">matplotlib.numerix</a><br>
<a href="pickle.html">pickle</a><br>
<a href="string.html">string</a><br>
<a href="sys.html">sys</a><br>
</td><td width="25%" valign=top><a href="matplotlib.ticker.html">matplotlib.ticker</a><br>
<a href="types.html">types</a><br>
<a href="warnings.html">warnings</a><br>
</td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#eeaa77">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Functions</strong></big></font></td></tr>
<tr><td bgcolor="#eeaa77"><tt> </tt></td><td> </td>
<td width="100%"><dl><dt><a name="-acorr"><strong>acorr</strong></a>(*args, **kwargs)</dt><dd><tt>ACORR(x, normed=False, detrend=detrend_none, usevlines=False,<br>
maxlags=None, **kwargs)<br>
Plot the autocorrelation of x. If normed=True, normalize the<br>
data but the autocorrelation at 0-th lag. x is detrended by<br>
the detrend callable (default no normalization.<br>
data are plotted as <a href="#-plot">plot</a>(lags, c, **kwargs)<br>
return value is lags, c, line where lags are a length<br>
2*maxlags+1 lag vector, c is the 2*maxlags+1 auto correlation<br>
vector, and line is a Line2D instance returned by plot. The<br>
default linestyle is None and the default marker is 'o',<br>
though these can be overridden with keyword args. The cross<br>
correlation is performed with numerix cross_correlate with<br>
mode=2.<br>
If usevlines is True, Axes.vlines rather than Axes.plot is used<br>
to draw vertical lines from the origin to the acorr.<br>
Otherwise the plotstyle is determined by the kwargs, which are<br>
Line2D properties. If usevlines, the return value is lags, c,<br>
linecol, b where linecol is the LineCollection and b is the x-axis<br>
if usevlines=True, kwargs are passed onto Axes.vlines<br>
if usevlines=False, kwargs are passed onto Axes.plot<br>
maxlags is a positive integer detailing the number of lags to show.<br>
The default value of None will return all (2*len(x)-1) lags.<br>
See the respective function for documentation on valid kwargs<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-annotate"><strong>annotate</strong></a>(*args, **kwargs)</dt><dd><tt><a href="#-annotate">annotate</a>(self, s, xy, textloc,<br>
xycoords='data', textcoords='data',<br>
lineprops=None,<br>
markerprops=None<br>
**props)<br>
alpha: float<br>
animated: [True | False]<br>
axes: an axes instance<br>
backgroundcolor: any matplotlib color<br>
bbox: rectangle prop dict plus key 'pad' which is a pad in points<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color: any matplotlib color<br>
family: [ 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ]<br>
figure: a matplotlib.figure.Figure instance<br>
fontproperties: a matplotlib.font_manager.FontProperties instance<br>
horizontalalignment or ha: [ 'center' | 'right' | 'left' ]<br>
label: any string<br>
lod: [True | False]<br>
multialignment: ['left' | 'right' | 'center' ]<br>
name or fontname: string eg, ['Sans' | 'Courier' | 'Helvetica' ...]<br>
picker: [None|float|boolean|callable]<br>
position: (x,y)<br>
rotation: [ angle in degrees 'vertical' | 'horizontal'<br>
size or fontsize: [ size in points | relative size eg 'smaller', 'x-large' ]<br>
style or fontstyle: [ 'normal' | 'italic' | 'oblique']<br>
text: string or anything printable with '%s' conversion<br>
transform: a matplotlib.transform transformation instance<br>
variant: [ 'normal' | 'small-caps' ]<br>
verticalalignment or va: [ 'center' | 'top' | 'bottom' ]<br>
visible: [True | False]<br>
weight or fontweight: [ 'normal' | 'bold' | 'heavy' | 'light' | 'ultrabold' | 'ultralight']<br>
x: float<br>
y: float<br>
zorder: any number</tt></dd></dl>
<dl><dt><a name="-arrow"><strong>arrow</strong></a>(*args, **kwargs)</dt><dd><tt>Draws arrow on specified axis from (x,y) to (x+dx,y+dy).<br>
Optional kwargs control the arrow properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-autumn"><strong>autumn</strong></a>()</dt><dd><tt>set the default colormap to autumn and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-axes"><strong>axes</strong></a>(*args, **kwargs)</dt><dd><tt>Add an axes at positon rect specified by::<br>
<br>
<a href="#-axes">axes</a>() by itself creates a default full <a href="#-subplot">subplot</a>(111) window axis<br>
<br>
<a href="#-axes">axes</a>(rect, axisbg='w') where rect=[left, bottom, width, height] in<br>
normalized (0,1) units. axisbg is the background color for the<br>
axis, default white<br>
<br>
<a href="#-axes">axes</a>(h) where h is an axes instance makes h the<br>
current axis An Axes instance is returned<br>
<br>
kwargs:<br>
<br>
axisbg=color : the axes background color<br>
frameon=False : don't display the frame<br>
sharex=otherax : the current axes shares xaxis attribute with otherax<br>
sharey=otherax : the current axes shares yaxis attribute with otherax<br>
polar=True|False : use a polar axes or not<br>
<br>
Examples<br>
<br>
examples/axes_demo.py places custom axes.<br>
examples/shared_axis_demo.py uses sharex and sharey</tt></dd></dl>
<dl><dt><a name="-axhline"><strong>axhline</strong></a>(*args, **kwargs)</dt><dd><tt>AXHLINE(y=0, xmin=0, xmax=1, **kwargs)<br>
Axis Horizontal Line<br>
Draw a horizontal line at y from xmin to xmax. With the default<br>
values of xmin=0 and xmax=1, this line will always span the horizontal<br>
extent of the axes, regardless of the xlim settings, even if you<br>
change them, eg with the xlim command. That is, the horizontal extent<br>
is in axes coords: 0=left, 0.5=middle, 1.0=right but the y location is<br>
in data coordinates.<br>
Return value is the Line2D instance. kwargs are the same as kwargs to<br>
plot, and can be used to control the line properties. Eg<br>
# draw a thick red hline at y=0 that spans the xrange<br>
<a href="#-axhline">axhline</a>(linewidth=4, color='r')<br>
# draw a default hline at y=1 that spans the xrange<br>
<a href="#-axhline">axhline</a>(y=1)<br>
# draw a default hline at y=.5 that spans the the middle half of<br>
# the xrange<br>
<a href="#-axhline">axhline</a>(y=.5, xmin=0.25, xmax=0.75)<br>
Valid kwargs are Line2D properties<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-axhspan"><strong>axhspan</strong></a>(*args, **kwargs)</dt><dd><tt>AXHSPAN(ymin, ymax, xmin=0, xmax=1, **kwargs)<br>
Axis Horizontal Span. ycoords are in data units and x<br>
coords are in axes (relative 0-1) units<br>
Draw a horizontal span (regtangle) from ymin to ymax. With the<br>
default values of xmin=0 and xmax=1, this always span the xrange,<br>
regardless of the xlim settings, even if you change them, eg with the<br>
xlim command. That is, the horizontal extent is in axes coords:<br>
0=left, 0.5=middle, 1.0=right but the y location is in data<br>
coordinates.<br>
kwargs are the kwargs to Patch, eg<br>
antialiased, aa<br>
linewidth, lw<br>
edgecolor, ec<br>
facecolor, fc<br>
the terms on the right are aliases<br>
Return value is the patches.Polygon instance.<br>
#draws a gray rectangle from y=0.25-0.75 that spans the horizontal<br>
#extent of the axes<br>
<a href="#-axhspan">axhspan</a>(0.25, 0.75, facecolor='0.5', alpha=0.5)<br>
Valid kwargs are Polygon properties<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-axis"><strong>axis</strong></a>(*v, **kwargs)</dt><dd><tt>Set/Get the axis properties::<br>
<br>
v = <a href="#-axis">axis</a>() returns the current axes as v = [xmin, xmax, ymin, ymax]<br>
<br>
<a href="#-axis">axis</a>(v) where v = [xmin, xmax, ymin, ymax] sets the min and max<br>
of the x and y axes<br>
<br>
<a href="#-axis">axis</a>('off') turns off the axis lines and labels<br>
<br>
<a href="#-axis">axis</a>('equal') changes limits of x or y axis so that equal<br>
increments of x and y have the same length; a circle<br>
is circular.<br>
<br>
<a href="#-axis">axis</a>('scaled') achieves the same result by changing the<br>
dimensions of the plot box instead of the axis data<br>
limits.<br>
<br>
<a href="#-axis">axis</a>('tight') changes x and y axis limits such that all data is<br>
shown. If all data is already shown, it will move it to the center<br>
of the figure without modifying (xmax-xmin) or (ymax-ymin). Note<br>
this is slightly different than in matlab.<br>
<br>
<a href="#-axis">axis</a>('image') is 'scaled' with the axis limits equal to the<br>
data limits.<br>
<br>
<a href="#-axis">axis</a>('auto') or 'normal' (deprecated) restores default behavior;<br>
axis limits are automatically scaled to make the data fit<br>
comfortably within the plot box.<br>
<br>
if len(*v)==0, you can pass in xmin, xmax, ymin, ymax as kwargs<br>
selectively to alter just those limits w/o changing the others.<br>
See help(xlim) and help(ylim) for more information<br>
<br>
The xmin, xmax, ymin, ymax tuple is returned</tt></dd></dl>
<dl><dt><a name="-axvline"><strong>axvline</strong></a>(*args, **kwargs)</dt><dd><tt>AXVLINE(x=0, ymin=0, ymax=1, **kwargs)<br>
Axis Vertical Line<br>
Draw a vertical line at x from ymin to ymax. With the default values<br>
of ymin=0 and ymax=1, this line will always span the vertical extent<br>
of the axes, regardless of the xlim settings, even if you change them,<br>
eg with the xlim command. That is, the vertical extent is in axes<br>
coords: 0=bottom, 0.5=middle, 1.0=top but the x location is in data<br>
coordinates.<br>
Return value is the Line2D instance. kwargs are the same as<br>
kwargs to plot, and can be used to control the line properties. Eg<br>
# draw a thick red vline at x=0 that spans the yrange<br>
l = <a href="#-axvline">axvline</a>(linewidth=4, color='r')<br>
# draw a default vline at x=1 that spans the yrange<br>
l = <a href="#-axvline">axvline</a>(x=1)<br>
# draw a default vline at x=.5 that spans the the middle half of<br>
# the yrange<br>
<a href="#-axvline">axvline</a>(x=.5, ymin=0.25, ymax=0.75)<br>
Valid kwargs are Line2D properties<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-axvspan"><strong>axvspan</strong></a>(*args, **kwargs)</dt><dd><tt>AXVSPAN(xmin, xmax, ymin=0, ymax=1, **kwargs)<br>
axvspan : Axis Vertical Span. xcoords are in data units and y coords<br>
are in axes (relative 0-1) units<br>
Draw a vertical span (regtangle) from xmin to xmax. With the default<br>
values of ymin=0 and ymax=1, this always span the yrange, regardless<br>
of the ylim settings, even if you change them, eg with the ylim<br>
command. That is, the vertical extent is in axes coords: 0=bottom,<br>
0.5=middle, 1.0=top but the y location is in data coordinates.<br>
kwargs are the kwargs to Patch, eg<br>
antialiased, aa<br>
linewidth, lw<br>
edgecolor, ec<br>
facecolor, fc<br>
the terms on the right are aliases<br>
return value is the patches.Polygon instance.<br>
# draw a vertical green translucent rectangle from x=1.25 to 1.55 that<br>
# spans the yrange of the axes<br>
<a href="#-axvspan">axvspan</a>(1.25, 1.55, facecolor='g', alpha=0.5)<br>
Valid kwargs are Polygon properties<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-bar"><strong>bar</strong></a>(*args, **kwargs)</dt><dd><tt>BAR(left, height, width=0.8, bottom=0,<br>
color=None, edgecolor=None, linewidth=None,<br>
yerr=None, xerr=None, ecolor=None, capsize=3,<br>
align='edge', orientation='vertical', log=False)<br>
Make a bar plot with rectangles bounded by<br>
left, left+width, bottom, bottom+height<br>
(left, right, bottom and top edges)<br>
left, height, width, and bottom can be either scalars or sequences<br>
Return value is a list of Rectangle patch instances<br>
left - the x coordinates of the left sides of the bars<br>
height - the heights of the bars<br>
Optional arguments:<br>
width - the widths of the bars<br>
bottom - the y coordinates of the bottom edges of the bars<br>
color - the colors of the bars<br>
edgecolor - the colors of the bar edges<br>
linewidth - width of bar edges; None means use default<br>
linewidth; 0 means don't draw edges.<br>
xerr and yerr, if not None, will be used to generate errorbars<br>
on the bar chart<br>
ecolor specifies the color of any errorbar<br>
capsize (default 3) determines the length in points of the error<br>
bar caps<br>
align = 'edge' (default) | 'center'<br>
orientation = 'vertical' | 'horizontal'<br>
log = False | True - False (default) leaves the orientation<br>
axis as-is; True sets it to log scale<br>
For vertical bars, align='edge' aligns bars by their left edges in<br>
left, while 'center' interprets these values as the x coordinates of<br>
the bar centers. For horizontal bars, 'edge' aligns bars by their<br>
bottom edges in bottom, while 'center' interprets these values as the<br>
y coordinates of the bar centers.<br>
The optional arguments color, edgecolor, linewidth, xerr, and yerr can<br>
be either scalars or sequences of length equal to the number of bars.<br>
This enables you to use bar as the basis for stacked bar charts, or<br>
candlestick plots.<br>
Optional kwargs:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-barh"><strong>barh</strong></a>(*args, **kwargs)</dt><dd><tt>BARH(bottom, width, height=0.8, left=0, **kwargs)<br>
Make a horizontal bar plot with rectangles bounded by<br>
left, left+width, bottom, bottom+height<br>
(left, right, bottom and top edges)<br>
bottom, width, height, and left can be either scalars or sequences<br>
Return value is a list of Rectangle patch instances<br>
bottom - the vertical positions of the bottom edges of the bars<br>
width - the lengths of the bars<br>
Optional arguments:<br>
height - the heights (thicknesses) of the bars<br>
left - the x coordinates of the left edges of the bars<br>
color - the colors of the bars<br>
edgecolor - the colors of the bar edges<br>
linewidth - width of bar edges; None means use default<br>
linewidth; 0 means don't draw edges.<br>
xerr and yerr, if not None, will be used to generate errorbars<br>
on the bar chart<br>
ecolor specifies the color of any errorbar<br>
capsize (default 3) determines the length in points of the error<br>
bar caps<br>
align = 'edge' (default) | 'center'<br>
log = False | True - False (default) leaves the horizontal<br>
axis as-is; True sets it to log scale<br>
Setting align='edge' aligns bars by their bottom edges in bottom,<br>
while 'center' interprets these values as the y coordinates of the bar<br>
centers.<br>
The optional arguments color, edgecolor, linewidth, xerr, and yerr can<br>
be either scalars or sequences of length equal to the number of bars.<br>
This enables you to use barh as the basis for stacked bar charts, or<br>
candlestick plots.<br>
Optional kwargs:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-bone"><strong>bone</strong></a>()</dt><dd><tt>set the default colormap to bone and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-box"><strong>box</strong></a>(on<font color="#909090">=None</font>)</dt><dd><tt>Turn the axes box on or off according to 'on'<br>
<br>
If on is None, toggle state</tt></dd></dl>
<dl><dt><a name="-boxplot"><strong>boxplot</strong></a>(*args, **kwargs)</dt><dd><tt><a href="#-boxplot">boxplot</a>(x, notch=0, sym='+', vert=1, whis=1.5,<br>
positions=None, widths=None)<br>
Make a box and whisker plot for each column of x or<br>
each vector in sequence x.<br>
The box extends from the lower to upper quartile values<br>
of the data, with a line at the median. The whiskers<br>
extend from the box to show the range of the data. Flier<br>
points are those past the end of the whiskers.<br>
notch = 0 (default) produces a rectangular box plot.<br>
notch = 1 will produce a notched box plot<br>
sym (default 'b+') is the default symbol for flier points.<br>
Enter an empty string ('') if you don't want to show fliers.<br>
vert = 1 (default) makes the boxes vertical.<br>
vert = 0 makes horizontal boxes. This seems goofy, but<br>
that's how Matlab did it.<br>
whis (default 1.5) defines the length of the whiskers as<br>
a function of the inner quartile range. They extend to the<br>
most extreme data point within ( whis*(75%-25%) ) data range.<br>
positions (default 1,2,...,n) sets the horizontal positions of<br>
the boxes. The ticks and limits are automatically set to match<br>
the positions.<br>
widths is either a scalar or a vector and sets the width of<br>
each box. The default is 0.5, or 0.15*(distance between extreme<br>
positions) if that is smaller.<br>
x is an array or a sequence of vectors.<br>
Returns a list of the lines added.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-broken_barh"><strong>broken_barh</strong></a>(*args, **kwargs)</dt><dd><tt>A collection of horizontal bars spanning yrange with a sequence of<br>
xranges<br>
xranges : sequence of (xmin, xwidth)<br>
yrange : (ymin, ywidth)<br>
kwargs are collections.BrokenBarHCollection properties<br>
alpha: float<br>
animated: [True | False]<br>
array: unknown<br>
axes: an axes instance<br>
clim: a length 2 sequence of floats<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
cmap: a colormap<br>
color: matplotlib color arg or sequence of rgba tuples<br>
colorbar: unknown<br>
edgecolor: matplotlib color arg or sequence of rgba tuples<br>
facecolor: matplotlib color arg or sequence of rgba tuples<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linewidth: float or sequence of floats<br>
lod: [True | False]<br>
norm: unknown<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
these can either be a single argument, ie facecolors='black'<br>
or a sequence of arguments for the various bars, ie<br>
facecolors='black', 'red', 'green'<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-cla"><strong>cla</strong></a>(*args, **kwargs)</dt><dd><tt>Clear the current axes</tt></dd></dl>
<dl><dt><a name="-clabel"><strong>clabel</strong></a>(*args, **kwargs)</dt><dd><tt><a href="#-clabel">clabel</a>(CS, **kwargs) - add labels to line contours in CS,<br>
where CS is a ContourSet object returned by contour.<br>
<a href="#-clabel">clabel</a>(CS, V, **kwargs) - only label contours listed in V<br>
keyword arguments:<br>
* fontsize = None: as described in <a href="http://matplotlib.sf.net/fonts.html">http://matplotlib.sf.net/fonts.html</a><br>
* colors = None:<br>
- a tuple of matplotlib color args (string, float, rgb, etc),<br>
different labels will be plotted in different colors in the order<br>
specified<br>
- one string color, e.g. colors = 'r' or colors = 'red', all labels<br>
will be plotted in this color<br>
- if colors == None, the color of each label matches the color<br>
of the corresponding contour<br>
* inline = True: controls whether the underlying contour is removed<br>
(inline = True) or not (False)<br>
* fmt = '%1.3f': a format string for the label<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-clf"><strong>clf</strong></a>()</dt><dd><tt>Clear the current figure</tt></dd></dl>
<dl><dt><a name="-clim"><strong>clim</strong></a>(vmin<font color="#909090">=None</font>, vmax<font color="#909090">=None</font>)</dt><dd><tt>Set the color limits of the current image<br>
<br>
To apply clim to all axes images do<br>
<br>
<a href="#-clim">clim</a>(0, 0.5)<br>
<br>
If either vmin or vmax is None, the image min/max respectively<br>
will be used for color scaling.<br>
<br>
If you want to set the clim of multiple images,<br>
use, for example for im in <a href="#-gca">gca</a>().get_images(): im.set_clim(0,<br>
0.05)</tt></dd></dl>
<dl><dt><a name="-close"><strong>close</strong></a>(*args)</dt><dd><tt>Close a figure window<br>
<br>
<a href="#-close">close</a>() by itself closes the current figure<br>
<br>
<a href="#-close">close</a>(num) closes figure number num<br>
<br>
<a href="#-close">close</a>(h) where h is a figure handle(instance) closes that figure<br>
<br>
<a href="#-close">close</a>('all') closes all the figure windows</tt></dd></dl>
<dl><dt><a name="-cohere"><strong>cohere</strong></a>(*args, **kwargs)</dt><dd><tt>COHERE(x, y, NFFT=256, Fs=2, detrend=detrend_none,<br>
window=window_hanning, noverlap=0, **kwargs)<br>
cohere the coherence between x and y. Coherence is the normalized<br>
cross spectral density<br>
Cxy = |Pxy|^2/(Pxx*Pyy)<br>
The return value is (Cxy, f), where f are the frequencies of the<br>
coherence vector.<br>
See the PSD help for a description of the optional parameters.<br>
kwargs are applied to the lines<br>
Returns the tuple Cxy, freqs<br>
Refs: Bendat & Piersol -- Random Data: Analysis and Measurement<br>
Procedures, John Wiley & Sons (1986)<br>
kwargs control the Line2D properties of the coherence plot:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-colorbar"><strong>colorbar</strong></a>(mappable<font color="#909090">=None</font>, cax<font color="#909090">=None</font>, **kw)</dt><dd><tt>Add a colorbar to a plot.<br>
<br>
Function signatures:<br>
<br>
<a href="#-colorbar">colorbar</a>(**kwargs)<br>
<br>
<a href="#-colorbar">colorbar</a>(mappable, **kwargs)<br>
<br>
<a href="#-colorbar">colorbar</a>(mappable, cax, **kwargs)<br>
<br>
The optional arguments mappable and cax may be included in the kwargs;<br>
they are image, ContourSet, etc. to which the colorbar applies, and<br>
the axes object in which the colorbar will be drawn. Defaults are<br>
the current image and a new axes object created next to that image<br>
after resizing the image.<br>
<br>
kwargs are in two groups:<br>
axes properties:<br>
<br>
fraction = 0.15; fraction of original axes to use for colorbar<br>
pad = 0.05 if vertical, 0.15 if horizontal; fraction<br>
of original axes between colorbar and<br>
new image axes<br>
shrink = 1.0; fraction by which to shrink the colorbar<br>
aspect = 20; ratio of long to short dimensions<br>
<br>
<br>
colorbar properties:<br>
<br>
extend='neither', 'both', 'min', 'max'<br>
If not 'neither', make pointed end(s) for out-of-range<br>
values. These are set for a given colormap using the<br>
colormap set_under and set_over methods.<br>
spacing='uniform', 'proportional'<br>
Uniform spacing gives each discrete color the same space;<br>
proportional makes the space proportional to the data interval.<br>
ticks=None, list of ticks, Locator object<br>
If None, ticks are determined automatically from the input.<br>
format=None, format string, Formatter object<br>
If none, the ScalarFormatter is used.<br>
If a format string is given, e.g. '%.3f', that is used.<br>
An alternative Formatter object may be given instead.<br>
drawedges=False, True<br>
If true, draw lines at color boundaries.<br>
<br>
The following will probably be useful only in the context of<br>
indexed colors (that is, when the mappable has norm=NoNorm()),<br>
or other unusual circumstances.<br>
<br>
boundaries=None or a sequence<br>
values=None or a sequence which must be of length 1 less than the<br>
sequence of boundaries.<br>
For each region delimited by adjacent entries in<br>
boundaries, the color mapped to the corresponding<br>
value in values will be used.<br>
<br>
<br>
<br>
If mappable is a ContourSet, its extend kwarg is included automatically.<br>
<br>
Note that the shrink kwarg provides a simple way to keep<br>
a vertical colorbar, for example, from being taller than<br>
the axes of the mappable to which the colorbar is attached;<br>
but it is a manual method requiring some trial and error.<br>
If the colorbar is too tall (or a horizontal colorbar is<br>
too wide) use a smaller value of shrink.<br>
<br>
For more precise control, you can manually specify the<br>
positions of the axes objects in which the mappable and<br>
the colorbar are drawn. In this case, do not use any of the<br>
axes properties kwargs.</tt></dd></dl>
<dl><dt><a name="-colorbar_classic"><strong>colorbar_classic</strong></a>(mappable<font color="#909090">=None</font>, cax<font color="#909090">=None</font>, orientation<font color="#909090">='vertical'</font>, tickfmt<font color="#909090">='%1.1f'</font>, cspacing<font color="#909090">='proportional'</font>, clabels<font color="#909090">=None</font>, drawedges<font color="#909090">=False</font>, edgewidth<font color="#909090">=0.5</font>, edgecolor<font color="#909090">='k'</font>)</dt><dd><tt>Create a colorbar for mappable; if mappable is None,<br>
use current image.<br>
<br>
tickfmt is a format string to format the colorbar ticks<br>
<br>
cax is a colorbar axes instance in which the colorbar will be<br>
placed. If None, as default axesd will be created resizing the<br>
current aqxes to make room for it. If not None, the supplied axes<br>
will be used and the other axes positions will be unchanged.<br>
<br>
orientation is the colorbar orientation: one of 'vertical' | 'horizontal'<br>
<br>
cspacing controls how colors are distributed on the colorbar.<br>
if cspacing == 'linear', each color occupies an equal area<br>
on the colorbar, regardless of the contour spacing.<br>
if cspacing == 'proportional' (Default), the area each color<br>
occupies on the the colorbar is proportional to the contour interval.<br>
Only relevant for a Contour image.<br>
<br>
clabels can be a sequence containing the<br>
contour levels to be labelled on the colorbar, or None (Default).<br>
If clabels is None, labels for all contour intervals are<br>
displayed. Only relevant for a Contour image.<br>
<br>
if drawedges == True, lines are drawn at the edges between<br>
each color on the colorbar. Default False.<br>
<br>
edgecolor is the line color delimiting the edges of the colors<br>
on the colorbar (if drawedges == True). Default black ('k')<br>
<br>
edgewidth is the width of the lines delimiting the edges of<br>
the colors on the colorbar (if drawedges == True). Default 0.5<br>
<br>
return value is the colorbar axes instance</tt></dd></dl>
<dl><dt><a name="-colormaps"><strong>colormaps</strong></a>()</dt><dd><tt>matplotlib provides the following colormaps.<br>
<br>
autumn bone cool copper flag gray hot hsv jet pink prism<br>
spring summer winter spectral<br>
<br>
You can set the colormap for an image, pcolor, scatter, etc,<br>
either as a keyword argumentdef con<br>
<br>
>>> <a href="#-imshow">imshow</a>(X, cmap=cm.hot)<br>
<br>
or post-hoc using the corresponding pylab interface function<br>
<br>
>>> <a href="#-imshow">imshow</a>(X)<br>
>>> <a href="#-hot">hot</a>()<br>
>>> <a href="#-jet">jet</a>()<br>
<br>
In interactive mode, this will update the colormap allowing you to<br>
see which one works best for your data.</tt></dd></dl>
<dl><dt><a name="-colors"><strong>colors</strong></a>()</dt><dd><tt>This is a do nothing function to provide you with help on how<br>
matplotlib handles colors.<br>
<br>
Commands which take color arguments can use several formats to<br>
specify the colors. For the basic builtin colors, you can use a<br>
single letter<br>
<br>
b : blue<br>
g : green<br>
r : red<br>
c : cyan<br>
m : magenta<br>
y : yellow<br>
k : black<br>
w : white<br>
<br>
<br>
For a greater range of colors, you have two options. You can<br>
specify the color using an html hex string, as in<br>
<br>
color = '#eeefff'<br>
<br>
or you can pass an R,G,B tuple, where each of R,G,B are in the<br>
range [0,1].<br>
<br>
You can also use any legal html name for a color, like 'red',<br>
'burlywood' and 'chartreuse'<br>
<br>
The example below creates a subplot with a dark<br>
slate gray background<br>
<br>
<a href="#-subplot">subplot</a>(111, axisbg=(0.1843, 0.3098, 0.3098))<br>
<br>
Here is an example that creates a pale turqoise title<br>
<br>
<a href="#-title">title</a>('Is this the best color?', color='#afeeee')</tt></dd></dl>
<dl><dt><a name="-concatenate"><strong>concatenate</strong></a>(...)</dt><dd><tt><a href="#-concatenate">concatenate</a>((a1, a2, ...), axis=0)<br>
<br>
Join arrays together.<br>
<br>
The tuple of sequences (a1, a2, ...) are joined along the given axis<br>
(default is the first one) into a single numpy array.<br>
<br>
Example:<br>
<br>
>>> <a href="#-concatenate">concatenate</a>( ([0,1,2], [5,6,7]) )<br>
array([0, 1, 2, 5, 6, 7])</tt></dd></dl>
<dl><dt><a name="-connect"><strong>connect</strong></a>(s, func)</dt><dd><tt>Connect event with string s to func. The signature of func is<br>
def func(event)<br>
where event is a MplEvent. The following events are recognized<br>
'resize_event',<br>
'draw_event',<br>
'key_press_event',<br>
'key_release_event',<br>
'button_press_event',<br>
'button_release_event',<br>
'motion_notify_event',<br>
'pick_event', <br>
<br>
<br>
For the three events above, if the mouse is over the axes,<br>
the variable event.inaxes will be set to the axes it is over,<br>
and additionally, the variables event.xdata and event.ydata<br>
will be defined. This is the mouse location in data coords.<br>
See backend_bases.MplEvent.<br>
<br>
return value is a connection id that can be used with<br>
mpl_disconnect</tt></dd></dl>
<dl><dt><a name="-contour"><strong>contour</strong></a>(*args, **kwargs)</dt><dd><tt>contour and contourf draw contour lines and filled contours,<br>
respectively. Except as noted, function signatures and return<br>
values are the same for both versions.<br>
contourf differs from the Matlab (TM) version in that it does not<br>
draw the polygon edges, because the contouring engine yields<br>
simply connected regions with branch cuts. To draw the edges,<br>
add line contours with calls to contour.<br>
Function signatures<br>
<a href="#-contour">contour</a>(Z) - make a contour plot of an array Z. The level<br>
values are chosen automatically.<br>
<a href="#-contour">contour</a>(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface<br>
<a href="#-contour">contour</a>(Z,N) and <a href="#-contour">contour</a>(X,Y,Z,N) - contour N automatically-chosen<br>
levels.<br>
<a href="#-contour">contour</a>(Z,V) and <a href="#-contour">contour</a>(X,Y,Z,V) - draw len(V) contour lines,<br>
at the values specified in sequence V<br>
<a href="#-contourf">contourf</a>(..., V) - fill the (len(V)-1) regions between the<br>
values in V<br>
<a href="#-contour">contour</a>(Z, **kwargs) - Use keyword args to control colors, linewidth,<br>
origin, cmap ... see below<br>
X, Y, and Z must be arrays with the same dimensions.<br>
Z may be a masked array, but filled contouring may not handle<br>
internal masked regions correctly.<br>
C = <a href="#-contour">contour</a>(...) returns a ContourSet object.<br>
Optional keyword args are shown with their defaults below (you must<br>
use kwargs for these):<br>
* colors = None; or one of the following:<br>
- a tuple of matplotlib color args (string, float, rgb, etc),<br>
different levels will be plotted in different colors in the order<br>
specified<br>
- one string color, e.g. colors = 'r' or colors = 'red', all levels<br>
will be plotted in this color<br>
- if colors == None, the colormap specified by cmap will be used<br>
* alpha=1.0 : the alpha blending value<br>
* cmap = None: a cm Colormap instance from matplotlib.cm.<br>
- if cmap == None and colors == None, a default Colormap is used.<br>
* norm = None: a matplotlib.colors.Normalize instance for<br>
scaling data values to colors.<br>
- if norm == None, and colors == None, the default<br>
linear scaling is used.<br>
* origin = None: 'upper'|'lower'|'image'|None.<br>
If 'image', the rc value for image.origin will be used.<br>
If None (default), the first value of Z will correspond<br>
to the lower left corner, location (0,0).<br>
This keyword is active only if contourf is called with<br>
one or two arguments, that is, without explicitly<br>
specifying X and Y.<br>
* extent = None: (x0,x1,y0,y1); also active only if X and Y<br>
are not specified. If origin is not None, then extent is<br>
interpreted as in imshow: it gives the outer pixel boundaries.<br>
In this case, the position of Z[0,0] is the center of the<br>
pixel, not a corner.<br>
If origin is None, then (x0,y0) is the position of Z[0,0],<br>
and (x1,y1) is the position of Z[-1,-1].<br>
* locator = None: an instance of a ticker.Locator subclass;<br>
default is MaxNLocator. It is used to determine the<br>
contour levels if they are not given explicitly via the<br>
V argument.<br>
***** New: *****<br>
* extend = 'neither', 'both', 'min', 'max'<br>
Unless this is 'neither' (default), contour levels are<br>
automatically added to one or both ends of the range so that<br>
all data are included. These added ranges are then<br>
mapped to the special colormap values which default to<br>
the ends of the colormap range, but can be set via<br>
Colormap.set_under() and Colormap.set_over() methods.<br>
To replace clip_ends=True and V = [-100, 2, 1, 0, 1, 2, 100],<br>
use extend='both' and V = [2, 1, 0, 1, 2].<br>
****************<br>
contour only:<br>
* linewidths = None: or one of these:<br>
- a number - all levels will be plotted with this linewidth,<br>
e.g. linewidths = 0.6<br>
- a tuple of numbers, e.g. linewidths = (0.4, 0.8, 1.2) different<br>
levels will be plotted with different linewidths in the order<br>
specified<br>
- if linewidths == None, the default width in lines.linewidth in<br>
matplotlibrc is used<br>
contourf only:<br>
***** Obsolete: ****<br>
* clip_ends = True<br>
If False, the limits for color scaling are set to the<br>
minimum and maximum contour levels.<br>
True (default) clips the scaling limits. Example:<br>
if the contour boundaries are V = [-100, 2, 1, 0, 1, 2, 100],<br>
then the scaling limits will be [-100, 100] if clip_ends<br>
is False, and [-3, 3] if clip_ends is True.<br>
* linewidths = None or a number; default of 0.05 works for<br>
Postscript; a value of about 0.5 seems better for Agg.<br>
* antialiased = True (default) or False; if False, there is<br>
no need to increase the linewidths for Agg, but True gives<br>
nicer color boundaries. If antialiased is True and linewidths<br>
is too small, then there may be light-colored lines at the<br>
color boundaries caused by the antialiasing.<br>
* nchunk = 0 (default) for no subdivision of the domain;<br>
specify a positive integer to divide the domain into<br>
subdomains of roughly nchunk by nchunk points. This may<br>
never actually be advantageous, so this option may be<br>
removed. Chunking introduces artifacts at the chunk<br>
boundaries unless antialiased = False, or linewidths is<br>
set to a large enough value for the particular renderer and<br>
resolution.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-contourf"><strong>contourf</strong></a>(*args, **kwargs)</dt><dd><tt>contour and contourf draw contour lines and filled contours,<br>
respectively. Except as noted, function signatures and return<br>
values are the same for both versions.<br>
contourf differs from the Matlab (TM) version in that it does not<br>
draw the polygon edges, because the contouring engine yields<br>
simply connected regions with branch cuts. To draw the edges,<br>
add line contours with calls to contour.<br>
Function signatures<br>
<a href="#-contour">contour</a>(Z) - make a contour plot of an array Z. The level<br>
values are chosen automatically.<br>
<a href="#-contour">contour</a>(X,Y,Z) - X,Y specify the (x,y) coordinates of the surface<br>
<a href="#-contour">contour</a>(Z,N) and <a href="#-contour">contour</a>(X,Y,Z,N) - contour N automatically-chosen<br>
levels.<br>
<a href="#-contour">contour</a>(Z,V) and <a href="#-contour">contour</a>(X,Y,Z,V) - draw len(V) contour lines,<br>
at the values specified in sequence V<br>
<a href="#-contourf">contourf</a>(..., V) - fill the (len(V)-1) regions between the<br>
values in V<br>
<a href="#-contour">contour</a>(Z, **kwargs) - Use keyword args to control colors, linewidth,<br>
origin, cmap ... see below<br>
X, Y, and Z must be arrays with the same dimensions.<br>
Z may be a masked array, but filled contouring may not handle<br>
internal masked regions correctly.<br>
C = <a href="#-contour">contour</a>(...) returns a ContourSet object.<br>
Optional keyword args are shown with their defaults below (you must<br>
use kwargs for these):<br>
* colors = None; or one of the following:<br>
- a tuple of matplotlib color args (string, float, rgb, etc),<br>
different levels will be plotted in different colors in the order<br>
specified<br>
- one string color, e.g. colors = 'r' or colors = 'red', all levels<br>
will be plotted in this color<br>
- if colors == None, the colormap specified by cmap will be used<br>
* alpha=1.0 : the alpha blending value<br>
* cmap = None: a cm Colormap instance from matplotlib.cm.<br>
- if cmap == None and colors == None, a default Colormap is used.<br>
* norm = None: a matplotlib.colors.Normalize instance for<br>
scaling data values to colors.<br>
- if norm == None, and colors == None, the default<br>
linear scaling is used.<br>
* origin = None: 'upper'|'lower'|'image'|None.<br>
If 'image', the rc value for image.origin will be used.<br>
If None (default), the first value of Z will correspond<br>
to the lower left corner, location (0,0).<br>
This keyword is active only if contourf is called with<br>
one or two arguments, that is, without explicitly<br>
specifying X and Y.<br>
* extent = None: (x0,x1,y0,y1); also active only if X and Y<br>
are not specified. If origin is not None, then extent is<br>
interpreted as in imshow: it gives the outer pixel boundaries.<br>
In this case, the position of Z[0,0] is the center of the<br>
pixel, not a corner.<br>
If origin is None, then (x0,y0) is the position of Z[0,0],<br>
and (x1,y1) is the position of Z[-1,-1].<br>
* locator = None: an instance of a ticker.Locator subclass;<br>
default is MaxNLocator. It is used to determine the<br>
contour levels if they are not given explicitly via the<br>
V argument.<br>
***** New: *****<br>
* extend = 'neither', 'both', 'min', 'max'<br>
Unless this is 'neither' (default), contour levels are<br>
automatically added to one or both ends of the range so that<br>
all data are included. These added ranges are then<br>
mapped to the special colormap values which default to<br>
the ends of the colormap range, but can be set via<br>
Colormap.set_under() and Colormap.set_over() methods.<br>
To replace clip_ends=True and V = [-100, 2, 1, 0, 1, 2, 100],<br>
use extend='both' and V = [2, 1, 0, 1, 2].<br>
****************<br>
contour only:<br>
* linewidths = None: or one of these:<br>
- a number - all levels will be plotted with this linewidth,<br>
e.g. linewidths = 0.6<br>
- a tuple of numbers, e.g. linewidths = (0.4, 0.8, 1.2) different<br>
levels will be plotted with different linewidths in the order<br>
specified<br>
- if linewidths == None, the default width in lines.linewidth in<br>
matplotlibrc is used<br>
contourf only:<br>
***** Obsolete: ****<br>
* clip_ends = True<br>
If False, the limits for color scaling are set to the<br>
minimum and maximum contour levels.<br>
True (default) clips the scaling limits. Example:<br>
if the contour boundaries are V = [-100, 2, 1, 0, 1, 2, 100],<br>
then the scaling limits will be [-100, 100] if clip_ends<br>
is False, and [-3, 3] if clip_ends is True.<br>
* linewidths = None or a number; default of 0.05 works for<br>
Postscript; a value of about 0.5 seems better for Agg.<br>
* antialiased = True (default) or False; if False, there is<br>
no need to increase the linewidths for Agg, but True gives<br>
nicer color boundaries. If antialiased is True and linewidths<br>
is too small, then there may be light-colored lines at the<br>
color boundaries caused by the antialiasing.<br>
* nchunk = 0 (default) for no subdivision of the domain;<br>
specify a positive integer to divide the domain into<br>
subdomains of roughly nchunk by nchunk points. This may<br>
never actually be advantageous, so this option may be<br>
removed. Chunking introduces artifacts at the chunk<br>
boundaries unless antialiased = False, or linewidths is<br>
set to a large enough value for the particular renderer and<br>
resolution.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-cool"><strong>cool</strong></a>()</dt><dd><tt>set the default colormap to cool and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-copper"><strong>copper</strong></a>()</dt><dd><tt>set the default colormap to copper and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-csd"><strong>csd</strong></a>(*args, **kwargs)</dt><dd><tt>CSD(x, y, NFFT=256, Fs=2, detrend=detrend_none,<br>
window=window_hanning, noverlap=0, **kwargs)<br>
The cross spectral density Pxy by Welches average periodogram method.<br>
The vectors x and y are divided into NFFT length segments. Each<br>
segment is detrended by function detrend and windowed by function<br>
window. The product of the direct FFTs of x and y are averaged over<br>
each segment to compute Pxy, with a scaling to correct for power loss<br>
due to windowing.<br>
See the PSD help for a description of the optional parameters.<br>
Returns the tuple Pxy, freqs. Pxy is the cross spectrum (complex<br>
valued), and 10*log10(|Pxy|) is plotted<br>
Refs:<br>
Bendat & Piersol -- Random Data: Analysis and Measurement<br>
Procedures, John Wiley & Sons (1986)<br>
kwargs control the Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-delaxes"><strong>delaxes</strong></a>(*args)</dt><dd><tt><a href="#-delaxes">delaxes</a>(ax) - remove ax from the current figure. If ax doesn't<br>
exist an error will be raised.<br>
<br>
<a href="#-delaxes">delaxes</a>(): delete the current axes</tt></dd></dl>
<dl><dt><a name="-disconnect"><strong>disconnect</strong></a>(cid)</dt><dd><tt>disconnect callback id cid</tt></dd></dl>
<dl><dt><a name="-dot"><strong>dot</strong></a>(...)</dt><dd><tt><a href="#-dot">dot</a>(a,b)<br>
Returns the dot product of a and b for arrays of floating point types.<br>
Like the generic numpy equivalent the product sum is over<br>
the last dimension of a and the second-to-last dimension of b.<br>
NB: The first argument is not conjugated.</tt></dd></dl>
<dl><dt><a name="-draw"><strong>draw</strong></a>()</dt><dd><tt>redraw the current figure</tt></dd></dl>
<dl><dt><a name="-dump"><strong>dump</strong></a>(...)</dt><dd><tt><a href="#-dump">dump</a>(obj, file, protocol=0) -- Write an object in pickle format to the given file.<br>
<br>
See the Pickler docstring for the meaning of optional argument proto.</tt></dd></dl>
<dl><dt><a name="-dumps"><strong>dumps</strong></a>(...)</dt><dd><tt><a href="#-dumps">dumps</a>(obj, protocol=0) -- Return a string containing an object in pickle format.<br>
<br>
See the Pickler docstring for the meaning of optional argument proto.</tt></dd></dl>
<dl><dt><a name="-errorbar"><strong>errorbar</strong></a>(*args, **kwargs)</dt><dd><tt>ERRORBAR(x, y, yerr=None, xerr=None,<br>
fmt='b-', ecolor=None, capsize=3, barsabove=False)<br>
Plot x versus y with error deltas in yerr and xerr.<br>
Vertical errorbars are plotted if yerr is not None<br>
Horizontal errorbars are plotted if xerr is not None<br>
xerr and yerr may be any of:<br>
a rank-0, Nx1 Numpy array - symmetric errorbars +/- value<br>
an N-element list or tuple - symmetric errorbars +/- value<br>
a rank-1, Nx2 Numpy array - asymmetric errorbars -column1/+column2<br>
Alternatively, x, y, xerr, and yerr can all be scalars, which<br>
plots a single error bar at x, y.<br>
fmt is the plot format symbol for y. if fmt is None, just<br>
plot the errorbars with no line symbols. This can be useful<br>
for creating a bar plot with errorbars<br>
ecolor is a matplotlib color arg which gives the color the<br>
errorbar lines; if None, use the marker color.<br>
capsize is the size of the error bar caps in points<br>
barsabove, if True, will plot the errorbars above the plot symbols<br>
- default is below<br>
kwargs are passed on to the plot command for the markers.<br>
So you can add additional key=value pairs to control the<br>
errorbar markers. For example, this code makes big red<br>
squares with thick green edges<br>
>>> x,y,yerr = <a href="#-rand">rand</a>(3,10)<br>
>>> <a href="#-errorbar">errorbar</a>(x, y, yerr, marker='s',<br>
mfc='red', mec='green', ms=20, mew=4)<br>
mfc, mec, ms and mew are aliases for the longer property<br>
names, markerfacecolor, markeredgecolor, markersize and<br>
markeredgewith.<br>
valid kwargs for the marker properties are<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
Return value is a length 3 tuple. The first element is the<br>
Line2D instance for the y symbol lines. The second element is<br>
a list of error bar cap lines, the third element is a list of<br>
line collections for the horizontal and vertical error ranges<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-figimage"><strong>figimage</strong></a>(*args, **kwargs)</dt><dd><tt>FIGIMAGE(X) # add non-resampled array to figure<br>
FIGIMAGE(X, xo, yo) # with pixel offsets<br>
FIGIMAGE(X, **kwargs) # control interpolation ,scaling, etc<br>
Add a nonresampled figure to the figure from array X. xo and yo are<br>
offsets in pixels<br>
X must be a float array<br>
If X is MxN, assume luminance (grayscale)<br>
If X is MxNx3, assume RGB<br>
If X is MxNx4, assume RGBA<br>
The following kwargs are allowed:<br>
* cmap is a cm colormap instance, eg cm.jet. If None, default to<br>
the rc image.cmap valuex<br>
* norm is a matplotlib.colors.Normalize instance; default is<br>
normalization(). This scales luminance -> 0-1<br>
* vmin and vmax are used to scale a luminance image to 0-1. If<br>
either is None, the min and max of the luminance values will be<br>
used. Note if you pass a norm instance, the settings for vmin and<br>
vmax will be ignored.<br>
* alpha = 1.0 : the alpha blending value<br>
* origin is either 'upper' or 'lower', which indicates where the [0,0]<br>
index of the array is in the upper left or lower left corner of<br>
the axes. Defaults to the rc image.origin value<br>
This complements the axes image (Axes.imshow) which will be resampled<br>
to fit the current axes. If you want a resampled image to fill the<br>
entire figure, you can define an Axes with size [0,1,0,1].<br>
A image.FigureImage instance is returned.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-figlegend"><strong>figlegend</strong></a>(handles, labels, loc, **kwargs)</dt><dd><tt>Place a legend in the figure. Labels are a sequence of<br>
strings, handles is a sequence of line or patch instances, and<br>
loc can be a string r an integer specifying the legend<br>
location<br>
<br>
USAGE:<br>
<a href="#-legend">legend</a>( (line1, line2, line3),<br>
('label1', 'label2', 'label3'),<br>
'upper right')<br>
<br>
See help(legend) for information about the location codes<br>
<br>
A matplotlib.legend.Legend instance is returned</tt></dd></dl>
<dl><dt><a name="-figtext"><strong>figtext</strong></a>(*args, **kwargs)</dt><dd><tt>Add text to figure at location x,y (relative 0-1 coords) See<br>
the help for Axis text for the meaning of the other arguments<br>
kwargs control the Text properties:<br>
alpha: float<br>
animated: [True | False]<br>
axes: an axes instance<br>
backgroundcolor: any matplotlib color<br>
bbox: rectangle prop dict plus key 'pad' which is a pad in points<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color: any matplotlib color<br>
family: [ 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ]<br>
figure: a matplotlib.figure.Figure instance<br>
fontproperties: a matplotlib.font_manager.FontProperties instance<br>
horizontalalignment or ha: [ 'center' | 'right' | 'left' ]<br>
label: any string<br>
lod: [True | False]<br>
multialignment: ['left' | 'right' | 'center' ]<br>
name or fontname: string eg, ['Sans' | 'Courier' | 'Helvetica' ...]<br>
picker: [None|float|boolean|callable]<br>
position: (x,y)<br>
rotation: [ angle in degrees 'vertical' | 'horizontal'<br>
size or fontsize: [ size in points | relative size eg 'smaller', 'x-large' ]<br>
style or fontstyle: [ 'normal' | 'italic' | 'oblique']<br>
text: string or anything printable with '%s' conversion<br>
transform: a matplotlib.transform transformation instance<br>
variant: [ 'normal' | 'small-caps' ]<br>
verticalalignment or va: [ 'center' | 'top' | 'bottom' ]<br>
visible: [True | False]<br>
weight or fontweight: [ 'normal' | 'bold' | 'heavy' | 'light' | 'ultrabold' | 'ultralight']<br>
x: float<br>
y: float<br>
zorder: any number</tt></dd></dl>
<dl><dt><a name="-figure"><strong>figure</strong></a>(num<font color="#909090">=None</font>, figsize<font color="#909090">=None</font>, dpi<font color="#909090">=None</font>, facecolor<font color="#909090">=None</font>, edgecolor<font color="#909090">=None</font>, frameon<font color="#909090">=True</font>, FigureClass<font color="#909090">=<class matplotlib.figure.Figure at 0x845f14c></font>, **kwargs)</dt><dd><tt><a href="#-figure">figure</a>(num = None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')<br>
<br>
<br>
Create a new figure and return a handle to it. If num=None, the figure<br>
number will be incremented and a new figure will be created. The returned<br>
figure objects have a .number attribute holding this number.<br>
<br>
If num is an integer, and <a href="#-figure">figure</a>(num) already exists, make it<br>
active and return the handle to it. If <a href="#-figure">figure</a>(num) does not exist<br>
it will be created. Numbering starts at 1, matlab style<br>
<br>
<a href="#-figure">figure</a>(1)<br>
<br>
If you are creating many figures, make sure you explicitly call "close"<br>
on the figures you are not using, because this will enable pylab<br>
to properly clean up the memory.<br>
<br>
kwargs:<br>
<br>
figsize - width x height in inches; defaults to rc figure.figsize<br>
dpi - resolution; defaults to rc figure.dpi<br>
facecolor - the background color; defaults to rc figure.facecolor<br>
edgecolor - the border color; defaults to rc figure.edgecolor<br>
<br>
rcParams gives the default values from the matplotlibrc file<br>
<br>
FigureClass is a Figure or derived class that will be passed on to<br>
new_figure_manager in the backends which allows you to hook custom<br>
Figureclasses into the pylab interface. Additional kwargs will be<br>
passed on to your figure init function</tt></dd></dl>
<dl><dt><a name="-fill"><strong>fill</strong></a>(*args, **kwargs)</dt><dd><tt>FILL(*args, **kwargs)<br>
plot filled polygons. *args is a variable length argument, allowing<br>
for multiple x,y pairs with an optional color format string; see plot<br>
for details on the argument parsing. For example, all of the<br>
following are legal, assuming ax is an Axes instance:<br>
ax.<a href="#-fill">fill</a>(x,y) # plot polygon with vertices at x,y<br>
ax.<a href="#-fill">fill</a>(x,y, 'b' ) # plot polygon with vertices at x,y in blue<br>
An arbitrary number of x, y, color groups can be specified, as in<br>
ax.<a href="#-fill">fill</a>(x1, y1, 'g', x2, y2, 'r')<br>
Return value is a list of patches that were added<br>
The same color strings that plot supports are supported by the fill<br>
format string.<br>
kwargs control the Polygon properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-flag"><strong>flag</strong></a>()</dt><dd><tt>set the default colormap to flag and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-gca"><strong>gca</strong></a>(**kwargs)</dt><dd><tt>Return the current axis instance. This can be used to control<br>
axis properties either using set or the Axes methods.<br>
<br>
Example:<br>
<br>
<a href="#-plot">plot</a>(t,s)<br>
set(<a href="#-gca">gca</a>(), 'xlim', [0,10]) # set the x axis limits<br>
<br>
or<br>
<br>
<a href="#-plot">plot</a>(t,s)<br>
a = <a href="#-gca">gca</a>()<br>
a.set_xlim([0,10]) # does the same</tt></dd></dl>
<dl><dt><a name="-gcf"><strong>gcf</strong></a>()</dt><dd><tt>Return a handle to the current figure</tt></dd></dl>
<dl><dt><a name="-gci"><strong>gci</strong></a>()</dt><dd><tt>get the current ScalarMappable instance (image or patch<br>
collection), or None if no images or patch collections have been<br>
defined. The commands imshow and figimage create images<br>
instances, and the commands pcolor and scatter create patch<br>
collection instances</tt></dd></dl>
<dl><dt><a name="-get_current_fig_manager"><strong>get_current_fig_manager</strong></a>()</dt></dl>
<dl><dt><a name="-get_plot_commands"><strong>get_plot_commands</strong></a>()</dt></dl>
<dl><dt><a name="-gray"><strong>gray</strong></a>()</dt><dd><tt>set the default colormap to gray and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-grid"><strong>grid</strong></a>(*args, **kwargs)</dt><dd><tt>GRID(self, b=None, **kwargs)<br>
Set the axes grids on or off; b is a boolean<br>
if b is None and len(kwargs)==0, toggle the grid state. if<br>
kwargs are supplied, it is assumed that you want a grid and b<br>
is thus set to True<br>
kawrgs are used to set the grid line properties, eg<br>
ax.<a href="#-grid">grid</a>(color='r', linestyle='-', linewidth=2)<br>
Valid Line2D kwargs are<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number</tt></dd></dl>
<dl><dt><a name="-hist"><strong>hist</strong></a>(*args, **kwargs)</dt><dd><tt>HIST(x, bins=10, normed=0, bottom=None,<br>
align='edge', orientation='vertical', width=None,<br>
log=False, **kwargs)<br>
Compute the histogram of x. bins is either an integer number of<br>
bins or a sequence giving the bins. x are the data to be binned.<br>
The return values is (n, bins, patches)<br>
If normed is true, the first element of the return tuple will<br>
be the counts normalized to form a probability density, ie,<br>
n/(len(x)*dbin). In a probability density, the integral of<br>
the histogram should be one (we assume equally spaced bins);<br>
you can verify that with<br>
# trapezoidal integration of the probability density function<br>
from matplotlib.mlab import trapz<br>
pdf, bins, patches = ax.<a href="#-hist">hist</a>(...)<br>
print trapz(bins, pdf)<br>
align = 'edge' | 'center'. Interprets bins either as edge<br>
or center values<br>
orientation = 'horizontal' | 'vertical'. If horizontal, barh<br>
will be used and the "bottom" kwarg will be the left edges.<br>
width: the width of the bars. If None, automatically compute<br>
the width.<br>
log: if True, the histogram axis will be set to a log scale<br>
kwargs are used to update the properties of the<br>
hist Rectangles:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
edgecolor or ec: any matplotlib color<br>
facecolor or fc: any matplotlib color<br>
figure: a matplotlib.figure.Figure instance<br>
fill: [True | False]<br>
hatch: unknown<br>
label: any string<br>
linewidth or lw: float<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-hlines"><strong>hlines</strong></a>(*args, **kwargs)</dt><dd><tt>HLINES(y, xmin, xmax, colors='k', linestyle='solid', **kwargs)<br>
plot horizontal lines at each y from xmin to xmax. xmin or xmax can<br>
be scalars or len(x) numpy arrays. If they are scalars, then the<br>
respective values are constant, else the widths of the lines are<br>
determined by xmin and xmax<br>
colors is a line collections color args, either a single color or a len(x) list of colors<br>
linestyle is one of solid|dashed|dashdot|dotted<br>
Returns the LineCollection that was added<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-hold"><strong>hold</strong></a>(b<font color="#909090">=None</font>)</dt><dd><tt>Set the hold state. If hold is None (default), toggle the<br>
hold state. Else set the hold state to boolean value b.<br>
<br>
Eg<br>
<a href="#-hold">hold</a>() # toggle hold<br>
<a href="#-hold">hold</a>(True) # hold is on<br>
<a href="#-hold">hold</a>(False) # hold is off<br>
<br>
When hold is True, subsequent plot commands will be added to the<br>
current axes. When hold is False, the current axes and figure<br>
will be cleared on the next plot command</tt></dd></dl>
<dl><dt><a name="-hot"><strong>hot</strong></a>()</dt><dd><tt>set the default colormap to hot and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-hsv"><strong>hsv</strong></a>()</dt><dd><tt>set the default colormap to hsv and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-imread"><strong>imread</strong></a>(*args, **kwargs)</dt><dd><tt>return image file in fname as numerix array<br>
Return value is a MxNx4 array of 0-1 normalized floats</tt></dd></dl>
<dl><dt><a name="-imshow"><strong>imshow</strong></a>(*args, **kwargs)</dt><dd><tt>IMSHOW(X, cmap=None, norm=None, aspect=None, interpolation=None,<br>
alpha=1.0, vmin=None, vmax=None, origin=None, extent=None)<br>
IMSHOW(X) - plot image X to current axes, resampling to scale to axes<br>
size (X may be numarray/Numeric array or PIL image)<br>
IMSHOW(X, **kwargs) - Use keyword args to control image scaling,<br>
colormapping etc. See below for details<br>
Display the image in X to current axes. X may be a float array, a<br>
UInt8 array or a PIL image. If X is an array, X can have the following<br>
shapes:<br>
MxN : luminance (grayscale, float array only)<br>
MxNx3 : RGB (float or UInt8 array)<br>
MxNx4 : RGBA (float or UInt8 array)<br>
The value for each component of MxNx3 and MxNx4 float arrays should be<br>
in the range 0.0 to 1.0; MxN float arrays may be normalised.<br>
A matplotlib.image.AxesImage instance is returned<br>
The following kwargs are allowed:<br>
* cmap is a cm colormap instance, eg cm.jet. If None, default to rc<br>
image.cmap value (Ignored when X has RGB(A) information)<br>
* aspect is one of: auto, equal, or a number. If None, default to rc<br>
image.aspect value<br>
* interpolation is one of:<br>
'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36',<br>
'hanning', 'hamming', 'hermite', 'kaiser', 'quadric',<br>
'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc',<br>
'lanczos', 'blackman'<br>
if interpolation is None, default to rc<br>
image.interpolation. See also th the filternorm and<br>
filterrad parameters<br>
* norm is a matplotlib.colors.Normalize instance; default is<br>
normalization(). This scales luminance -> 0-1 (only used for an<br>
MxN float array).<br>
* vmin and vmax are used to scale a luminance image to 0-1. If<br>
either is None, the min and max of the luminance values will be<br>
used. Note if you pass a norm instance, the settings for vmin and<br>
vmax will be ignored.<br>
* alpha = 1.0 : the alpha blending value<br>
* origin is 'upper' or 'lower', to place the [0,0]<br>
index of the array in the upper left or lower left corner of<br>
the axes. If None, default to rc image.origin<br>
* extent is (left, right, bottom, top) data values of the<br>
axes. The default assigns zero-based row, column indices<br>
to the x, y centers of the pixels.<br>
* shape is for raw buffer images<br>
* filternorm is a parameter for the antigrain image resize<br>
filter. From the antigrain documentation, if normalize=1,<br>
the filter normalizes integer values and corrects the<br>
rounding errors. It doesn't do anything with the source<br>
floating point values, it corrects only integers according<br>
to the rule of 1.0 which means that any sum of pixel<br>
weights must be equal to 1.0. So, the filter function<br>
must produce a graph of the proper shape.<br>
* filterrad: the filter radius for filters that have a radius<br>
parameter, ie when interpolation is one of: 'sinc',<br>
'lanczos' or 'blackman'<br>
Additional kwargs are matplotlib.artist properties<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-innerproduct"><strong>innerproduct</strong></a> = inner(...)</dt><dd><tt><a href="#-innerproduct">innerproduct</a>(a,b)<br>
Returns the inner product of a and b for arrays of floating point types.<br>
Like the generic NumPy equivalent the product sum is over<br>
the last dimension of a and b.<br>
NB: The first argument is not conjugated.</tt></dd></dl>
<dl><dt><a name="-ioff"><strong>ioff</strong></a>()</dt><dd><tt>turn interactive mode off</tt></dd></dl>
<dl><dt><a name="-ion"><strong>ion</strong></a>()</dt><dd><tt>turn interactive mode on</tt></dd></dl>
<dl><dt><a name="-ishold"><strong>ishold</strong></a>()</dt><dd><tt>Return the hold status of the current axes</tt></dd></dl>
<dl><dt><a name="-isinteractive"><strong>isinteractive</strong></a>()</dt><dd><tt>Return the interactive status</tt></dd></dl>
<dl><dt><a name="-jet"><strong>jet</strong></a>()</dt><dd><tt>set the default colormap to jet and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-legend"><strong>legend</strong></a>(*args, **kwargs)</dt><dd><tt>LEGEND(*args, **kwargs)<br>
Place a legend on the current axes at location loc. Labels are a<br>
sequence of strings and loc can be a string or an integer specifying<br>
the legend location<br>
USAGE:<br>
Make a legend with existing lines<br>
>>> <a href="#-legend">legend</a>()<br>
legend by itself will try and build a legend using the label<br>
property of the lines/patches/collections. You can set the label of<br>
a line by doing <a href="#-plot">plot</a>(x, y, label='my data') or line.set_label('my<br>
data'). If label is set to '_nolegend_', the item will not be shown<br>
in legend.<br>
# automatically generate the legend from labels<br>
<a href="#-legend">legend</a>( ('label1', 'label2', 'label3') )<br>
# Make a legend for a list of lines and labels<br>
<a href="#-legend">legend</a>( (line1, line2, line3), ('label1', 'label2', 'label3') )<br>
# Make a legend at a given location, using a location argument<br>
# <a href="#-legend">legend</a>( LABELS, LOC ) or<br>
# <a href="#-legend">legend</a>( LINES, LABELS, LOC )<br>
<a href="#-legend">legend</a>( ('label1', 'label2', 'label3'), loc='upper left')<br>
<a href="#-legend">legend</a>( (line1, line2, line3), ('label1', 'label2', 'label3'), loc=2)<br>
The location codes are<br>
'best' : 0,<br>
'upper right' : 1, (default)<br>
'upper left' : 2,<br>
'lower left' : 3,<br>
'lower right' : 4,<br>
'right' : 5,<br>
'center left' : 6,<br>
'center right' : 7,<br>
'lower center' : 8,<br>
'upper center' : 9,<br>
'center' : 10,<br>
If none of these are suitable, loc can be a 2-tuple giving x,y<br>
in axes coords, ie,<br>
loc = 0, 1 is left top<br>
loc = 0.5, 0.5 is center, center<br>
and so on. The following kwargs are supported:<br>
isaxes=True # whether this is an axes legend<br>
numpoints = 4 # the number of points in the legend line<br>
prop = FontProperties(size='smaller') # the font property<br>
pad = 0.2 # the fractional whitespace inside the legend border<br>
markerscale = 0.6 # the relative size of legend markers vs. original<br>
shadow # if True, draw a shadow behind legend<br>
labelsep = 0.005 # the vertical space between the legend entries<br>
handlelen = 0.05 # the length of the legend lines<br>
handletextsep = 0.02 # the space between the legend line and legend text<br>
axespad = 0.02 # the border between the axes and legend edge</tt></dd></dl>
<dl><dt><a name="-loglog"><strong>loglog</strong></a>(*args, **kwargs)</dt><dd><tt>LOGLOG(*args, **kwargs)<br>
Make a loglog plot with log scaling on the a and y axis. The args<br>
to semilog x are the same as the args to plot. See help plot for<br>
more info.<br>
Optional keyword args supported are any of the kwargs<br>
supported by plot or set_xscale or set_yscale. Notable, for<br>
log scaling:<br>
* basex: base of the x logarithm<br>
* subsx: the location of the minor ticks; None defaults to<br>
autosubs, which depend on the number of decades in the<br>
plot; see set_xscale for details<br>
* basey: base of the y logarithm<br>
* subsy: the location of the minor yticks; None defaults to<br>
autosubs, which depend on the number of decades in the<br>
plot; see set_yscale for details<br>
The remaining valid kwargs are Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-matshow"><strong>matshow</strong></a>(A, fignum<font color="#909090">=None</font>, **kw)</dt><dd><tt>Display an array as a matrix in a new figure window.<br>
<br>
The origin is set at the upper left hand corner and rows (first dimension<br>
of the array) are displayed horizontally. The aspect ratio of the figure<br>
window is that of the array, unless this would make an excessively<br>
short or narrow figure.<br>
<br>
Tick labels for the xaxis are placed on top.<br>
<br>
With one exception, keyword arguments are passed to<br>
<a href="#-imshow">imshow</a>().<br>
<br>
Special keyword argument which is NOT passed to <a href="#-imshow">imshow</a>():<br>
<br>
- fignum(None): by default, <a href="#-matshow">matshow</a>() creates a new figure window with<br>
automatic numbering. If fignum is given as an integer, the created<br>
figure will use this figure number. Because of how <a href="#-matshow">matshow</a>() tries to<br>
set the figure aspect ratio to be the one of the array, if you provide<br>
the number of an already existing figure, strange things may happen.<br>
<br>
if fignum is False or 0, a new figure window will NOT be created.<br>
<br>
Example usage:<br>
<br>
def samplemat(dims):<br>
aa = zeros(dims)<br>
for i in range(<a href="#-min">min</a>(dims)):<br>
aa[i,i] = i<br>
return aa<br>
<br>
dimlist = [(12,12),(128,64),(64,512),(2048,256)]<br>
<br>
for d in dimlist:<br>
im = <a href="#-matshow">matshow</a>(samplemat(d))<br>
show()</tt></dd></dl>
<dl><dt><a name="-max"><strong>max</strong></a>(...)</dt><dd><tt><a href="#-max">max</a>(iterable[, key=func]) -> value<br>
<a href="#-max">max</a>(a, b, c, ...[, key=func]) -> value<br>
<br>
With a single iterable argument, return its largest item.<br>
With two or more arguments, return the largest argument.</tt></dd></dl>
<dl><dt><a name="-min"><strong>min</strong></a>(...)</dt><dd><tt><a href="#-min">min</a>(iterable[, key=func]) -> value<br>
<a href="#-min">min</a>(a, b, c, ...[, key=func]) -> value<br>
<br>
With a single iterable argument, return its smallest item.<br>
With two or more arguments, return the smallest argument.</tt></dd></dl>
<dl><dt><a name="-over"><strong>over</strong></a>(func, *args, **kwargs)</dt><dd><tt>Call func(*args, **kwargs) with <a href="#-hold">hold</a>(True) and then restore the hold state</tt></dd></dl>
<dl><dt><a name="-pcolor"><strong>pcolor</strong></a>(*args, **kwargs)</dt><dd><tt><a href="#-pcolor">pcolor</a>(*args, **kwargs): pseudocolor plot of a 2-D array<br>
Function signatures<br>
<a href="#-pcolor">pcolor</a>(C, **kwargs)<br>
<a href="#-pcolor">pcolor</a>(X, Y, C, **kwargs)<br>
C is the array of color values<br>
X and Y, if given, specify the (x,y) coordinates of the colored<br>
quadrilaterals; the quadrilateral for C[i,j] has corners at<br>
(X[i,j],Y[i,j]), (X[i,j+1],Y[i,j+1]), (X[i+1,j],Y[i+1,j]),<br>
(X[i+1,j+1],Y[i+1,j+1]). Ideally the dimensions of X and Y<br>
should be one greater than those of C; if the dimensions are the<br>
same, then the last row and column of C will be ignored.<br>
Note that the the column index corresponds to the x-coordinate,<br>
and the row index corresponds to y; for details, see<br>
the "Grid Orientation" section below.<br>
If either or both of X and Y are 1-D arrays or column vectors,<br>
they will be expanded as needed into the appropriate 2-D arrays,<br>
making a rectangular grid.<br>
X,Y and C may be masked arrays. If either C[i,j], or one<br>
of the vertices surrounding C[i,j] (X or Y at [i,j],[i+1,j],<br>
[i,j+1],[i=1,j+1]) is masked, nothing is plotted.<br>
Optional keyword args are shown with their defaults below (you must<br>
use kwargs for these):<br>
* cmap = cm.jet : a cm Colormap instance from matplotlib.cm.<br>
defaults to cm.jet<br>
* norm = Normalize() : matplotlib.colors.Normalize instance<br>
is used to scale luminance data to 0,1.<br>
* vmin=None and vmax=None : vmin and vmax are used in conjunction<br>
with norm to normalize luminance data. If either are None, the<br>
min and max of the color array C is used. If you pass a norm<br>
instance, vmin and vmax will be None<br>
* shading = 'flat' : or 'faceted'. If 'faceted', a black grid is<br>
drawn around each rectangle; if 'flat', edges are not drawn<br>
* alpha=1.0 : the alpha blending value<br>
Return value is a matplotlib.collections.PatchCollection<br>
object<br>
Grid Orientation<br>
The orientation follows the Matlab(TM) convention: an<br>
array C with shape (nrows, ncolumns) is plotted with<br>
the column number as X and the row number as Y, increasing<br>
up; hence it is plotted the way the array would be printed,<br>
except that the Y axis is reversed. That is, C is taken<br>
as C(y,x).<br>
Similarly for meshgrid:<br>
x = arange(5)<br>
y = arange(3)<br>
X, Y = meshgrid(x,y)<br>
is equivalent to<br>
X = array([[0, 1, 2, 3, 4],<br>
[0, 1, 2, 3, 4],<br>
[0, 1, 2, 3, 4]])<br>
Y = array([[0, 0, 0, 0, 0],<br>
[1, 1, 1, 1, 1],<br>
[2, 2, 2, 2, 2]])<br>
so if you have<br>
C = <a href="#-rand">rand</a>( len(x), len(y))<br>
then you need<br>
<a href="#-pcolor">pcolor</a>(X, Y, transpose(C))<br>
or<br>
<a href="#-pcolor">pcolor</a>(transpose(C))<br>
Dimensions<br>
Matlab pcolor always discards<br>
the last row and column of C, but matplotlib displays<br>
the last row and column if X and Y are not specified, or<br>
if X and Y have one more row and column than C.<br>
kwargs can be used to control the PolyCollection properties:<br>
alpha: float<br>
animated: [True | False]<br>
array: unknown<br>
axes: an axes instance<br>
clim: a length 2 sequence of floats<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
cmap: a colormap<br>
color: matplotlib color arg or sequence of rgba tuples<br>
colorbar: unknown<br>
edgecolor: matplotlib color arg or sequence of rgba tuples<br>
facecolor: matplotlib color arg or sequence of rgba tuples<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linewidth: float or sequence of floats<br>
lod: [True | False]<br>
norm: unknown<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-pcolor_classic"><strong>pcolor_classic</strong></a>(*args, **kwargs)</dt><dd><tt>pcolor_classic is no longer available; please use pcolor,<br>
which is a drop-in replacement.</tt></dd></dl>
<dl><dt><a name="-pcolormesh"><strong>pcolormesh</strong></a>(*args, **kwargs)</dt><dd><tt>PCOLORMESH(*args, **kwargs)<br>
Function signatures<br>
PCOLORMESH(C) - make a pseudocolor plot of matrix C<br>
PCOLORMESH(X, Y, C) - a pseudo color plot of C on the matrices X and Y<br>
PCOLORMESH(C, **kwargs) - Use keyword args to control colormapping and<br>
scaling; see below<br>
C may be a masked array, but X and Y may not. Masked array support<br>
is implemented via cmap and norm; in contrast, pcolor simply does<br>
not draw quadrilaterals with masked colors or vertices.<br>
Optional keyword args are shown with their defaults below (you must<br>
use kwargs for these):<br>
* cmap = cm.jet : a cm Colormap instance from matplotlib.cm.<br>
defaults to cm.jet<br>
* norm = Normalize() : matplotlib.colors.Normalize instance<br>
is used to scale luminance data to 0,1. Instantiate it<br>
with clip=False if C is a masked array.<br>
* vmin=None and vmax=None : vmin and vmax are used in conjunction<br>
with norm to normalize luminance data. If either are None, the<br>
min and max of the color array C is used.<br>
* shading = 'flat' : or 'faceted'. If 'faceted', a black grid is<br>
drawn around each rectangle; if 'flat', edge colors are same as<br>
face colors<br>
* alpha=1.0 : the alpha blending value<br>
Return value is a matplotlib.collections.PatchCollection<br>
object<br>
See pcolor for an explantion of the grid orientation and the<br>
expansion of 1-D X and/or Y to 2-D arrays.<br>
kwargs can be used to control the QuadMesh polygon collection properties:<br>
alpha: float<br>
animated: [True | False]<br>
array: unknown<br>
axes: an axes instance<br>
clim: a length 2 sequence of floats<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
cmap: a colormap<br>
color: matplotlib color arg or sequence of rgba tuples<br>
colorbar: unknown<br>
edgecolor: matplotlib color arg or sequence of rgba tuples<br>
facecolor: matplotlib color arg or sequence of rgba tuples<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linewidth: float or sequence of floats<br>
lod: [True | False]<br>
norm: unknown<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-pie"><strong>pie</strong></a>(*args, **kwargs)</dt><dd><tt>PIE(x, explode=None, labels=None,<br>
colors=('b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'),<br>
autopct=None, pctdistance=0.6, shadow=False)<br>
Make a pie chart of array x. The fractional area of each wedge is<br>
given by x/sum(x). If sum(x)<=1, then the values of x give the<br>
fractional area directly and the array will not be normalized.<br>
- explode, if not None, is a len(x) array which specifies the<br>
fraction of the radius to offset that wedge.<br>
- colors is a sequence of matplotlib color args that the pie chart<br>
will cycle.<br>
- labels, if not None, is a len(x) list of labels.<br>
- autopct, if not None, is a string or function used to label the<br>
wedges with their numeric value. The label will be placed inside<br>
the wedge. If it is a format string, the label will be fmt%pct.<br>
If it is a function, it will be called<br>
- pctdistance is the ratio between the center of each pie slice<br>
and the start of the text generated by autopct. Ignored if autopct<br>
is None; default is 0.6.<br>
- shadow, if True, will draw a shadow beneath the pie.<br>
The pie chart will probably look best if the figure and axes are<br>
square. Eg,<br>
<a href="#-figure">figure</a>(figsize=(8,8))<br>
ax = <a href="#-axes">axes</a>([0.1, 0.1, 0.8, 0.8])<br>
Return value:<br>
If autopct is None, return a list of (patches, texts), where patches<br>
is a sequence of matplotlib.patches.Wedge instances and texts is a<br>
list of the label Text instnaces<br>
If autopct is not None, return (patches, texts, autotexts), where<br>
patches and texts are as above, and autotexts is a list of text<br>
instances for the numeric labels<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-pink"><strong>pink</strong></a>()</dt><dd><tt>set the default colormap to pink and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-plot"><strong>plot</strong></a>(*args, **kwargs)</dt><dd><tt>PLOT(*args, **kwargs)<br>
Plot lines and/or markers to the Axes. *args is a variable length<br>
argument, allowing for multiple x,y pairs with an optional format<br>
string. For example, each of the following is legal<br>
<a href="#-plot">plot</a>(x,y) # plot x and y using the default line style and color<br>
<a href="#-plot">plot</a>(x,y, 'bo') # plot x and y using blue circle markers<br>
<a href="#-plot">plot</a>(y) # plot y using x as index array 0..N-1<br>
<a href="#-plot">plot</a>(y, 'r+') # ditto, but with red plusses<br>
If x and/or y is 2-Dimensional, then the corresponding columns<br>
will be plotted.<br>
An arbitrary number of x, y, fmt groups can be specified, as in<br>
a.<a href="#-plot">plot</a>(x1, y1, 'g^', x2, y2, 'g-')<br>
Return value is a list of lines that were added.<br>
The following line styles are supported:<br>
- : solid line<br>
-- : dashed line<br>
-. : dash-dot line<br>
: : dotted line<br>
. : points<br>
, : pixels<br>
o : circle symbols<br>
^ : triangle up symbols<br>
v : triangle down symbols<br>
< : triangle left symbols<br>
> : triangle right symbols<br>
s : square symbols<br>
+ : plus symbols<br>
x : cross symbols<br>
D : diamond symbols<br>
d : thin diamond symbols<br>
1 : tripod down symbols<br>
2 : tripod up symbols<br>
3 : tripod left symbols<br>
4 : tripod right symbols<br>
h : hexagon symbols<br>
H : rotated hexagon symbols<br>
p : pentagon symbols<br>
| : vertical line symbols<br>
_ : horizontal line symbols<br>
steps : use gnuplot style 'steps' # kwarg only<br>
The following color abbreviations are supported<br>
b : blue<br>
g : green<br>
r : red<br>
c : cyan<br>
m : magenta<br>
y : yellow<br>
k : black<br>
w : white<br>
In addition, you can specify colors in many weird and<br>
wonderful ways, including full names 'green', hex strings<br>
'#008000', RGB or RGBA tuples (0,1,0,1) or grayscale<br>
intensities as a string '0.8'.<br>
Line styles and colors are combined in a single format string, as in<br>
'bo' for blue circles.<br>
The **kwargs can be used to set line properties (any property that has<br>
a set_* method). You can use this to set a line label (for auto<br>
legends), linewidth, anitialising, marker face color, etc. Here is an<br>
example:<br>
<a href="#-plot">plot</a>([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)<br>
<a href="#-plot">plot</a>([1,2,3], [1,4,9], 'rs', label='line 2')<br>
<a href="#-axis">axis</a>([0, 4, 0, 10])<br>
<a href="#-legend">legend</a>()<br>
If you make multiple lines with one plot command, the kwargs apply<br>
to all those lines, eg<br>
<a href="#-plot">plot</a>(x1, y1, x2, y2, antialised=False)<br>
Neither line will be antialiased.<br>
The kwargs are Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
kwargs scalex and scaley, if defined, are passed on<br>
to autoscale_view to determine whether the x and y axes are<br>
autoscaled; default True. See Axes.autoscale_view for more<br>
information<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-plot_date"><strong>plot_date</strong></a>(*args, **kwargs)</dt><dd><tt>PLOT_DATE(x, y, fmt='bo', tz=None, xdate=True, ydate=False, **kwargs)<br>
Similar to the <a href="#-plot">plot</a>() command, except the x or y (or both) data<br>
is considered to be dates, and the axis is labeled accordingly.<br>
x or y (or both) can be a sequence of dates represented as<br>
float days since 0001-01-01 UTC.<br>
fmt is a plot format string.<br>
tz is the time zone to use in labelling dates. Defaults to rc value.<br>
If xdate is True, the x-axis will be labeled with dates.<br>
If ydate is True, the y-axis will be labeled with dates.<br>
Note if you are using custom date tickers and formatters, it<br>
may be necessary to set the formatters/locators after the call<br>
to plot_date since plot_date will set the default tick locator<br>
to AutoDateLocator (if the tick locator is not already set to<br>
a DateLocator instance) and the default tick formatter to<br>
AutoDateFormatter (if the tick formatter is not already set to<br>
a DateFormatter instance).<br>
Valid kwargs are Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
See matplotlib.dates for helper functions date2num, num2date<br>
and drange for help on creating the required floating point dates<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-plotting"><strong>plotting</strong></a>()</dt><dd><tt>Plotting commands<br>
axes - Create a new axes<br>
axis - Set or return the current axis limits<br>
bar - make a bar chart<br>
boxplot - make a box and whiskers chart<br>
cla - clear current axes<br>
clabel - label a contour plot<br>
clf - clear a figure window<br>
close - close a figure window<br>
colorbar - add a colorbar to the current figure<br>
cohere - make a plot of coherence<br>
contour - make a contour plot<br>
contourf - make a filled contour plot<br>
csd - make a plot of cross spectral density<br>
draw - force a redraw of the current figure<br>
errorbar - make an errorbar graph<br>
figlegend - add a legend to the figure<br>
figimage - add an image to the figure, w/o resampling<br>
figtext - add text in figure coords<br>
figure - create or change active figure<br>
fill - make filled polygons<br>
gca - return the current axes<br>
gcf - return the current figure<br>
gci - get the current image, or None<br>
get - get a handle graphics property<br>
hist - make a histogram<br>
hold - set the hold state on current axes<br>
legend - add a legend to the axes<br>
loglog - a log log plot<br>
imread - load image file into array<br>
imshow - plot image data<br>
matshow - display a matrix in a new figure preserving aspect<br>
pcolor - make a pseudocolor plot<br>
plot - make a line plot<br>
psd - make a plot of power spectral density<br>
quiver - make a direction field (arrows) plot<br>
rc - control the default params<br>
savefig - save the current figure<br>
scatter - make a scatter plot<br>
set - set a handle graphics property<br>
semilogx - log x axis<br>
semilogy - log y axis<br>
show - show the figures<br>
specgram - a spectrogram plot<br>
stem - make a stem plot<br>
subplot - make a subplot (numrows, numcols, axesnum)<br>
table - add a table to the axes<br>
text - add some text at location x,y to the current axes<br>
title - add a title to the current axes<br>
xlabel - add an xlabel to the current axes<br>
ylabel - add a ylabel to the current axes<br>
<br>
autumn - set the default colormap to autumn<br>
bone - set the default colormap to bone<br>
cool - set the default colormap to cool<br>
copper - set the default colormap to copper<br>
flag - set the default colormap to flag<br>
gray - set the default colormap to gray<br>
hot - set the default colormap to hot<br>
hsv - set the default colormap to hsv<br>
jet - set the default colormap to jet<br>
pink - set the default colormap to pink<br>
prism - set the default colormap to prism<br>
spring - set the default colormap to spring<br>
summer - set the default colormap to summer<br>
winter - set the default colormap to winter<br>
spectral - set the default colormap to spectral</tt></dd></dl>
<dl><dt><a name="-polar"><strong>polar</strong></a>(*args, **kwargs)</dt><dd><tt>POLAR(theta, r)<br>
<br>
Make a polar plot. Multiple theta, r arguments are supported,<br>
with format strings, as in plot.</tt></dd></dl>
<dl><dt><a name="-prism"><strong>prism</strong></a>()</dt><dd><tt>set the default colormap to prism and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-psd"><strong>psd</strong></a>(*args, **kwargs)</dt><dd><tt>PSD(x, NFFT=256, Fs=2, detrend=detrend_none,<br>
window=window_hanning, noverlap=0, **kwargs)<br>
The power spectral density by Welches average periodogram method. The<br>
vector x is divided into NFFT length segments. Each segment is<br>
detrended by function detrend and windowed by function window.<br>
noperlap gives the length of the overlap between segments. The<br>
absolute(fft(segment))**2 of each segment are averaged to compute Pxx,<br>
with a scaling to correct for power loss due to windowing. Fs is the<br>
sampling frequency.<br>
NFFT is the length of the fft segment; must be a power of 2<br>
Fs is the sampling frequency.<br>
detrend - the function applied to each segment before fft-ing,<br>
designed to remove the mean or linear trend. Unlike in matlab,<br>
where the detrend parameter is a vector, in matplotlib is it a<br>
function. The mlab module defines detrend_none, detrend_mean,<br>
detrend_linear, but you can use a custom function as well.<br>
window - the function used to window the segments. window is a<br>
function, unlike in matlab(TM) where it is a vector. mlab defines<br>
window_none, window_hanning, but you can use a custom function<br>
as well.<br>
noverlap gives the length of the overlap between segments.<br>
Returns the tuple Pxx, freqs<br>
For plotting, the power is plotted as 10*log10(pxx)) for decibels,<br>
though pxx itself is returned<br>
Refs:<br>
Bendat & Piersol -- Random Data: Analysis and Measurement<br>
Procedures, John Wiley & Sons (1986)<br>
kwargs control the Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-putmask"><strong>putmask</strong></a>(...)</dt><dd><tt><a href="#-putmask">putmask</a>(a, mask, values) sets a.flat[n] = values[n] for each n where<br>
mask.flat[n] is true. If values is not the same size of a and mask then<br>
it will repeat. This gives different behavior than a[mask] = values.</tt></dd></dl>
<dl><dt><a name="-pymax"><strong>pymax</strong></a> = max(...)</dt><dd><tt><a href="#-max">max</a>(iterable[, key=func]) -> value<br>
<a href="#-max">max</a>(a, b, c, ...[, key=func]) -> value<br>
<br>
With a single iterable argument, return its largest item.<br>
With two or more arguments, return the largest argument.</tt></dd></dl>
<dl><dt><a name="-pymin"><strong>pymin</strong></a> = min(...)</dt><dd><tt><a href="#-min">min</a>(iterable[, key=func]) -> value<br>
<a href="#-min">min</a>(a, b, c, ...[, key=func]) -> value<br>
<br>
With a single iterable argument, return its smallest item.<br>
With two or more arguments, return the smallest argument.</tt></dd></dl>
<dl><dt><a name="-quiver"><strong>quiver</strong></a>(*args, **kwargs)</dt><dd><tt>Plot a 2-D field of arrows.<br>
<br>
Function signatures:<br>
<br>
<a href="#-quiver">quiver</a>(U, V, **kw)<br>
<a href="#-quiver">quiver</a>(U, V, C, **kw)<br>
<a href="#-quiver">quiver</a>(X, Y, U, V, **kw)<br>
<a href="#-quiver">quiver</a>(X, Y, U, V, C, **kw)<br>
<br>
Arguments:<br>
<br>
X, Y give the x and y coordinates of the arrow locations<br>
(default is tail of arrow; see 'pivot' kwarg)<br>
U, V give the x and y components of the arrow vectors<br>
C is an optional array used to map colors to the arrows<br>
<br>
All arguments may be 1-D or 2-D arrays or sequences.<br>
If X and Y are absent, they will be generated as a uniform grid.<br>
If U and V are 2-D arrays but X and Y are 1-D, and if<br>
len(X) and len(Y) match the column and row dimensions<br>
of U, then X and Y will be expanded with meshgrid.<br>
<br>
Keyword arguments (default given first):<br>
<br>
* units = 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y'<br>
arrow units; the arrow dimensions *except for length*<br>
are in multiples of this unit.<br>
* scale = None | float<br>
data units per arrow unit, e.g. m/s per plot width;<br>
a smaller scale parameter makes the arrow longer.<br>
If None, a simple autoscaling algorithm is used, based<br>
on the average vector length and the number of vectors.<br>
<br>
Arrow dimensions and scales can be in any of several units:<br>
<br>
'width' or 'height': the width or height of the axes<br>
'dots' or 'inches': pixels or inches, based on the figure dpi<br>
'x' or 'y': X or Y data units<br>
<br>
In all cases the arrow aspect ratio is 1, so that if U==V the angle<br>
of the arrow on the plot is 45 degrees CCW from the X-axis.<br>
<br>
The arrows scale differently depending on the units, however.<br>
For 'x' or 'y', the arrows get larger as one zooms in; for other<br>
units, the arrow size is independent of the zoom state. For<br>
'width or 'height', the arrow size increases with the width and<br>
height of the axes, respectively, when the the window is resized;<br>
for 'dots' or 'inches', resizing does not change the arrows.<br>
<br>
<br>
* width = ? shaft width in arrow units; default depends on<br>
choice of units, above, and number of vectors;<br>
a typical starting value is about<br>
0.005 times the width of the plot.<br>
* headwidth = 3 head width as multiple of shaft width<br>
* headlength = 5 head length as multiple of shaft width<br>
* headaxislength = 4.5 head length at shaft intersection<br>
* minshaft = 1 length below which arrow scales, in units<br>
of head length. Do not set this to less<br>
than 1, or small arrows will look terrible!<br>
* minlength = 1 minimum length as a multiple of shaft width;<br>
if an arrow length is less than this, plot a<br>
dot (hexagon) of this diameter instead.<br>
<br>
The defaults give a slightly swept-back arrow; to make the<br>
head a triangle, make headaxislength the same as headlength.<br>
To make the arrow more pointed, reduce headwidth or increase<br>
headlength and headaxislength.<br>
To make the head smaller relative to the shaft, scale down<br>
all the head* parameters.<br>
You will probably do best to leave minshaft alone.<br>
<br>
* pivot = 'tail' | 'middle' | 'tip'<br>
The part of the arrow that is at the grid point; the arrow<br>
rotates about this point, hence the name 'pivot'.<br>
<br>
* color = 'k' | any matplotlib color spec or sequence of color specs.<br>
This is a synonym for the PolyCollection facecolor kwarg.<br>
If C has been set, 'color' has no effect.<br>
<br>
* All PolyCollection kwargs are valid, in the sense that they<br>
will be passed on to the PolyCollection constructor.<br>
In particular, one might want to use, for example:<br>
linewidths = (1,), edgecolors = ('g',)<br>
to make the arrows have green outlines of unit width.<br>
<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-quiver2"><strong>quiver2</strong></a>(*args, **kwargs)</dt><dd><tt>Plot a 2-D field of arrows.<br>
<br>
Function signatures:<br>
<br>
<a href="#-quiver">quiver</a>(U, V, **kw)<br>
<a href="#-quiver">quiver</a>(U, V, C, **kw)<br>
<a href="#-quiver">quiver</a>(X, Y, U, V, **kw)<br>
<a href="#-quiver">quiver</a>(X, Y, U, V, C, **kw)<br>
<br>
Arguments:<br>
<br>
X, Y give the x and y coordinates of the arrow locations<br>
(default is tail of arrow; see 'pivot' kwarg)<br>
U, V give the x and y components of the arrow vectors<br>
C is an optional array used to map colors to the arrows<br>
<br>
All arguments may be 1-D or 2-D arrays or sequences.<br>
If X and Y are absent, they will be generated as a uniform grid.<br>
If U and V are 2-D arrays but X and Y are 1-D, and if<br>
len(X) and len(Y) match the column and row dimensions<br>
of U, then X and Y will be expanded with meshgrid.<br>
<br>
Keyword arguments (default given first):<br>
<br>
* units = 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y'<br>
arrow units; the arrow dimensions *except for length*<br>
are in multiples of this unit.<br>
* scale = None | float<br>
data units per arrow unit, e.g. m/s per plot width;<br>
a smaller scale parameter makes the arrow longer.<br>
If None, a simple autoscaling algorithm is used, based<br>
on the average vector length and the number of vectors.<br>
<br>
Arrow dimensions and scales can be in any of several units:<br>
<br>
'width' or 'height': the width or height of the axes<br>
'dots' or 'inches': pixels or inches, based on the figure dpi<br>
'x' or 'y': X or Y data units<br>
<br>
In all cases the arrow aspect ratio is 1, so that if U==V the angle<br>
of the arrow on the plot is 45 degrees CCW from the X-axis.<br>
<br>
The arrows scale differently depending on the units, however.<br>
For 'x' or 'y', the arrows get larger as one zooms in; for other<br>
units, the arrow size is independent of the zoom state. For<br>
'width or 'height', the arrow size increases with the width and<br>
height of the axes, respectively, when the the window is resized;<br>
for 'dots' or 'inches', resizing does not change the arrows.<br>
<br>
<br>
* width = ? shaft width in arrow units; default depends on<br>
choice of units, above, and number of vectors;<br>
a typical starting value is about<br>
0.005 times the width of the plot.<br>
* headwidth = 3 head width as multiple of shaft width<br>
* headlength = 5 head length as multiple of shaft width<br>
* headaxislength = 4.5 head length at shaft intersection<br>
* minshaft = 1 length below which arrow scales, in units<br>
of head length. Do not set this to less<br>
than 1, or small arrows will look terrible!<br>
* minlength = 1 minimum length as a multiple of shaft width;<br>
if an arrow length is less than this, plot a<br>
dot (hexagon) of this diameter instead.<br>
<br>
The defaults give a slightly swept-back arrow; to make the<br>
head a triangle, make headaxislength the same as headlength.<br>
To make the arrow more pointed, reduce headwidth or increase<br>
headlength and headaxislength.<br>
To make the head smaller relative to the shaft, scale down<br>
all the head* parameters.<br>
You will probably do best to leave minshaft alone.<br>
<br>
* pivot = 'tail' | 'middle' | 'tip'<br>
The part of the arrow that is at the grid point; the arrow<br>
rotates about this point, hence the name 'pivot'.<br>
<br>
* color = 'k' | any matplotlib color spec or sequence of color specs.<br>
This is a synonym for the PolyCollection facecolor kwarg.<br>
If C has been set, 'color' has no effect.<br>
<br>
* All PolyCollection kwargs are valid, in the sense that they<br>
will be passed on to the PolyCollection constructor.<br>
In particular, one might want to use, for example:<br>
linewidths = (1,), edgecolors = ('g',)<br>
to make the arrows have green outlines of unit width.<br>
<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-quiverkey"><strong>quiverkey</strong></a>(*args, **kwargs)</dt><dd><tt>Add a key to a quiver plot.<br>
<br>
Function signature:<br>
<a href="#-quiverkey">quiverkey</a>(Q, X, Y, U, label, **kw)<br>
<br>
Arguments:<br>
Q is the Quiver instance returned by a call to quiver.<br>
X, Y give the location of the key; additional explanation follows.<br>
U is the length of the key<br>
label is a string with the length and units of the key<br>
<br>
Keyword arguments (default given first):<br>
* coordinates = 'axes' | 'figure' | 'data' | 'inches'<br>
Coordinate system and units for X, Y: 'axes' and 'figure'<br>
are normalized coordinate systems with 0,0 in the lower<br>
left and 1,1 in the upper right; 'data' are the axes<br>
data coordinates (used for the locations of the vectors<br>
in the quiver plot itself); 'inches' is position in the<br>
figure in inches, with 0,0 at the lower left corner.<br>
* color overrides face and edge colors from Q.<br>
* labelpos = 'N' | 'S' | 'E' | 'W'<br>
Position the label above, below, to the right, to the left<br>
of the arrow, respectively.<br>
* labelsep = 0.1 inches distance between the arrow and the label<br>
* labelcolor (defaults to default Text color)<br>
* fontproperties is a dictionary with keyword arguments accepted<br>
by the FontProperties initializer: family, style, variant,<br>
size, weight<br>
<br>
Any additional keyword arguments are used to override vector<br>
properties taken from Q.<br>
<br>
The positioning of the key depends on X, Y, coordinates, and<br>
labelpos. If labelpos is 'N' or 'S', X,Y give the position<br>
of the middle of the key arrow. If labelpos is 'E', X,Y<br>
positions the head, and if labelpos is 'W', X,Y positions the<br>
tail; in either of these two cases, X,Y is somewhere in the middle<br>
of the arrow+label key object.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-raise_msg_to_str"><strong>raise_msg_to_str</strong></a>(msg)</dt><dd><tt>msg is a return arg from a raise. Join with new lines</tt></dd></dl>
<dl><dt><a name="-rand"><strong>rand</strong></a>(...)</dt><dd><tt>Return an array of the given dimensions which is initialized to <br>
random numbers from a uniform distribution in the range [0,1).<br>
<br>
<a href="#-rand">rand</a>(d0, d1, ..., dn) -> random values<br>
<br>
Note: This is a convenience function. If you want an<br>
interface that takes a tuple as the first argument<br>
use numpy.random.random_sample(shape_tuple).</tt></dd></dl>
<dl><dt><a name="-randn"><strong>randn</strong></a>(...)</dt><dd><tt>Returns zero-mean, unit-variance Gaussian random numbers in an <br>
array of shape (d0, d1, ..., dn).<br>
<br>
<a href="#-randn">randn</a>(d0, d1, ..., dn) -> random values<br>
<br>
Note: This is a convenience function. If you want an<br>
interface that takes a tuple as the first argument<br>
use numpy.random.standard_normal(shape_tuple).</tt></dd></dl>
<dl><dt><a name="-rc"><strong>rc</strong></a>(*args, **kwargs)</dt><dd><tt>Set the current rc params. Group is the grouping for the rc, eg<br>
for lines.linewidth the group is 'lines', for axes.facecolor, the<br>
group is 'axes', and so on. Group may also be a list or tuple<br>
of group names, eg ('xtick','ytick'). kwargs is a list of<br>
attribute name/value pairs, eg<br>
<a href="#-rc">rc</a>('lines', linewidth=2, color='r')<br>
sets the current rc params and is equivalent to<br>
rcParams['lines.linewidth'] = 2<br>
rcParams['lines.color'] = 'r'<br>
The following aliases are available to save typing for interactive<br>
users<br>
'lw' : 'linewidth'<br>
'ls' : 'linestyle'<br>
'c' : 'color'<br>
'fc' : 'facecolor'<br>
'ec' : 'edgecolor'<br>
'mew' : 'markeredgewidth'<br>
'aa' : 'antialiased'<br>
Thus you could abbreviate the above rc command as<br>
<a href="#-rc">rc</a>('lines', lw=2, c='r')<br>
Note you can use python's kwargs dictionary facility to store<br>
dictionaries of default parameters. Eg, you can customize the<br>
font rc as follows<br>
font = {'family' : 'monospace',<br>
'weight' : 'bold',<br>
'size' : 'larger',<br>
}<br>
<a href="#-rc">rc</a>('font', **font) # pass in the font dict as kwargs<br>
This enables you to easily switch between several configurations.<br>
Use rcdefaults to restore the default rc params after changes.</tt></dd></dl>
<dl><dt><a name="-rcdefaults"><strong>rcdefaults</strong></a>()</dt><dd><tt>Restore the default rc params - the ones that were created at<br>
matplotlib load time</tt></dd></dl>
<dl><dt><a name="-rgrids"><strong>rgrids</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the radial locations of the gridlines and ticklabels<br>
<br>
With no args, simply return lines, labels where lines is an<br>
array of radial gridlines (Line2D instances) and labels is an<br>
array of tick labels (Text instances).<br>
<br>
lines, labels = <a href="#-rgrids">rgrids</a>()<br>
<br>
With arguments, the syntax is<br>
<br>
lines, labels = RGRIDS(radii, labels=None, angle=22.5, **kwargs)<br>
<br>
The labels will appear at radial distances radii at angle<br>
<br>
labels, if not None, is a len(radii) list of strings of the<br>
labels to use at each angle.<br>
<br>
if labels is None, the self.<strong>rformatter</strong> will be used<br>
<br>
Return value is a list of lines, labels where the lines are<br>
matplotlib.Line2D instances and the labels are matplotlib.Text<br>
instances. Note that on input the labels argument is a list of<br>
strings, and on output it is a list of Text instances<br>
<br>
Examples<br>
# set the locations of the radial gridlines and labels<br>
lines, labels = <a href="#-rgrids">rgrids</a>( (0.25, 0.5, 1.0) )<br>
<br>
# set the locations and labels of the radial gridlines and labels<br>
lines, labels = <a href="#-rgrids">rgrids</a>( (0.25, 0.5, 1.0), ('Tom', 'Dick', 'Harry' )</tt></dd></dl>
<dl><dt><a name="-savefig"><strong>savefig</strong></a>(*args, **kwargs)</dt><dd><tt>SAVEFIG(fname, dpi=None, facecolor='w', edgecolor='w',<br>
orientation='portrait', papertype=None, format=None):<br>
Save the current figure.<br>
fname - the filename to save the current figure to. The<br>
output formats supported depend on the backend being<br>
used. and are deduced by the extension to fname.<br>
Possibilities are eps, jpeg, pdf, png, ps, svg. fname<br>
can also be a file or file-like object - cairo backend<br>
only. dpi - is the resolution in dots per inch. If<br>
None it will default to the value savefig.dpi in the<br>
matplotlibrc file<br>
facecolor and edgecolor are the colors of the figure rectangle<br>
orientation is either 'landscape' or 'portrait' - not supported on<br>
all backends; currently only on postscript output<br>
papertype is is one of 'letter', 'legal', 'executive', 'ledger', 'a0'<br>
through 'a10', or 'b0' through 'b10' - only supported for postscript<br>
output<br>
format - one of 'pdf', 'png', 'ps', 'svg'. It is used to specify the<br>
output when fname is a file or file-like object - cairo<br>
backend only.</tt></dd></dl>
<dl><dt><a name="-scatter"><strong>scatter</strong></a>(*args, **kwargs)</dt><dd><tt>SCATTER(x, y, s=20, c='b', marker='o', cmap=None, norm=None,<br>
vmin=None, vmax=None, alpha=1.0, linewidths=None,<br>
faceted=True, **kwargs)<br>
Supported function signatures:<br>
SCATTER(x, y, **kwargs)<br>
SCATTER(x, y, s, **kwargs)<br>
SCATTER(x, y, s, c, **kwargs)<br>
Make a scatter plot of x versus y, where x, y are 1-D sequences<br>
of the same length, N.<br>
Arguments s and c can also be given as kwargs; this is encouraged<br>
for readability.<br>
s is a size in points^2. It is a scalar<br>
or an array of the same length as x and y.<br>
c is a color and can be a single color format string,<br>
or a sequence of color specifications of length N,<br>
or a sequence of N numbers to be mapped to colors<br>
using the cmap and norm specified via kwargs (see below).<br>
Note that c should not be a single numeric RGB or RGBA<br>
sequence because that is indistinguishable from an array<br>
of values to be colormapped. c can be a 2-D array in which<br>
the rows are RGB or RGBA, however.<br>
The marker can be one of<br>
's' : square<br>
'o' : circle<br>
'^' : triangle up<br>
'>' : triangle right<br>
'v' : triangle down<br>
'<' : triangle left<br>
'd' : diamond<br>
'p' : pentagram<br>
'h' : hexagon<br>
'8' : octagon<br>
If marker is None and verts is not None, verts is a sequence<br>
of (x,y) vertices for a custom scatter symbol.<br>
s is a size argument in points squared.<br>
Any or all of x, y, s, and c may be masked arrays, in which<br>
case all masks will be combined and only unmasked points<br>
will be plotted.<br>
Other keyword args; the color mapping and normalization arguments will<br>
on be used if c is an array of floats<br>
* cmap = cm.jet : a colors.Colormap instance from matplotlib.cm.<br>
defaults to rc image.cmap<br>
* norm = Normalize() : matplotlib.colors.Normalize instance<br>
is used to scale luminance data to 0,1.<br>
* vmin=None and vmax=None : vmin and vmax are used in conjunction<br>
with norm to normalize luminance data. If either are None, the<br>
min and max of the color array C is used. Note if you pass a norm<br>
instance, your settings for vmin and vmax will be ignored<br>
* alpha =1.0 : the alpha value for the patches<br>
* linewidths, if None, defaults to (lines.linewidth,). Note<br>
that this is a tuple, and if you set the linewidths<br>
argument you must set it as a sequence of floats, as<br>
required by RegularPolyCollection -- see<br>
matplotlib.collections.RegularPolyCollection for details<br>
* faceted: if True, will use the default edgecolor for the<br>
markers. If False, will set the edgecolors to be the same<br>
as the facecolors<br>
Optional kwargs control the PatchCollection properties:<br>
alpha: float<br>
animated: [True | False]<br>
array: unknown<br>
axes: an axes instance<br>
clim: a length 2 sequence of floats<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
cmap: a colormap<br>
color: matplotlib color arg or sequence of rgba tuples<br>
colorbar: unknown<br>
edgecolor: matplotlib color arg or sequence of rgba tuples<br>
facecolor: matplotlib color arg or sequence of rgba tuples<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linewidth: float or sequence of floats<br>
lod: [True | False]<br>
norm: unknown<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-scatter_classic"><strong>scatter_classic</strong></a>(*args, **kwargs)</dt><dd><tt>scatter_classic is no longer available; please use scatter.<br>
To help in porting, for comparison to the scatter docstring,<br>
here is the scatter_classic docstring:<br>
SCATTER_CLASSIC(x, y, s=None, c='b')<br>
Make a scatter plot of x versus y. s is a size (in data coords) and<br>
can be either a scalar or an array of the same length as x or y. c is<br>
a color and can be a single color format string or an length(x) array<br>
of intensities which will be mapped by the colormap jet.<br>
If size is None a default size will be used</tt></dd></dl>
<dl><dt><a name="-sci"><strong>sci</strong></a>(im)</dt><dd><tt>Set the current image (the target of colormap commands like jet, hot or clim)</tt></dd></dl>
<dl><dt><a name="-semilogx"><strong>semilogx</strong></a>(*args, **kwargs)</dt><dd><tt>SEMILOGX(*args, **kwargs)<br>
Make a semilog plot with log scaling on the x axis. The args to<br>
semilog x are the same as the args to plot. See help plot for more<br>
info.<br>
Optional keyword args supported are any of the kwargs supported by<br>
plot or set_xscale. Notable, for log scaling:<br>
* basex: base of the logarithm<br>
* subsx: the location of the minor ticks; None defaults to<br>
autosubs, which depend on the number of decades in the<br>
plot; see set_xscale for details<br>
The remaining valid kwargs are Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-semilogy"><strong>semilogy</strong></a>(*args, **kwargs)</dt><dd><tt>SEMILOGY(*args, **kwargs):<br>
Make a semilog plot with log scaling on the y axis. The args to<br>
semilogy are the same as the args to plot. See help plot for more<br>
info.<br>
Optional keyword args supported are any of the kwargs supported by<br>
plot or set_yscale. Notable, for log scaling:<br>
* basey: base of the logarithm<br>
* subsy: a sequence of the location of the minor ticks;<br>
None defaults to autosubs, which depend on the number of<br>
decades in the plot; see set_yscale for details<br>
The remaining valid kwargs are Line2D properties:<br>
alpha: float<br>
animated: [True | False]<br>
antialiased or aa: [True | False]<br>
axes: unknown<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color or c: any matplotlib color<br>
dash_capstyle: ['butt' | 'round' | 'projecting']<br>
dash_joinstyle: ['miter' | 'round' | 'bevel']<br>
dashes: sequence of on/off ink in points<br>
data: (array xdata, array ydata)<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle or ls: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' | ' ' | '' ]<br>
linewidth or lw: float value in points<br>
lod: [True | False]<br>
marker: [ '+' | ',' | '.' | '1' | '2' | '3' | '4'<br>
markeredgecolor or mec: any matplotlib color<br>
markeredgewidth or mew: float value in points<br>
markerfacecolor or mfc: any matplotlib color<br>
markersize or ms: float<br>
picker: [None|float|boolean|callable]<br>
solid_capstyle: ['butt' | 'round' | 'projecting']<br>
solid_joinstyle: ['miter' | 'round' | 'bevel']<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
xdata: array<br>
ydata: array<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-setp"><strong>setp</strong></a>(*args, **kwargs)</dt><dd><tt>matplotlib supports the use of setp ("set property") and getp to set<br>
and get object properties, as well as to do introspection on the<br>
object For example, to set the linestyle of a line to be dashed, you<br>
can do<br>
<br>
>>> line, = <a href="#-plot">plot</a>([1,2,3])<br>
>>> <a href="#-setp">setp</a>(line, linestyle='--')<br>
<br>
If you want to know the valid types of arguments, you can provide the<br>
name of the property you want to set without a value<br>
<br>
>>> <a href="#-setp">setp</a>(line, 'linestyle')<br>
linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]<br>
<br>
If you want to see all the properties that can be set, and their<br>
possible values, you can do<br>
<br>
<br>
>>> <a href="#-setp">setp</a>(line)<br>
... long output listing omitted'<br>
<br>
setp operates on a single instance or a list of instances. If you<br>
are in query mode introspecting the possible values, only the first<br>
instance in the sequence is used. When actually setting values,<br>
all the instances will be set. Eg, suppose you have a list of two<br>
lines, the following will make both lines thicker and red<br>
<br>
>>> x = arange(0,1.0,0.01)<br>
>>> y1 = sin(2*pi*x)<br>
>>> y2 = sin(4*pi*x)<br>
>>> lines = <a href="#-plot">plot</a>(x, y1, x, y2)<br>
>>> <a href="#-setp">setp</a>(lines, linewidth=2, color='r')<br>
<br>
setp works with the matlab(TM) style string/value pairs or with<br>
python kwargs. For example, the following are equivalent<br>
<br>
>>> <a href="#-setp">setp</a>(lines, 'linewidth', 2, 'color', r') # matlab style<br>
>>> <a href="#-setp">setp</a>(lines, linewidth=2, color='r') # python style</tt></dd></dl>
<dl><dt><a name="-specgram"><strong>specgram</strong></a>(*args, **kwargs)</dt><dd><tt>SPECGRAM(x, NFFT=256, Fs=2, detrend=detrend_none,<br>
window=window_hanning, noverlap=128,<br>
cmap=None, xextent=None)<br>
Compute a spectrogram of data in x. Data are split into NFFT length<br>
segements and the PSD of each section is computed. The windowing<br>
function window is applied to each segment, and the amount of overlap<br>
of each segment is specified with noverlap.<br>
* cmap is a colormap; if None use default determined by rc<br>
* xextent is the image extent in the xaxes xextent=xmin, xmax -<br>
default 0, <a href="#-max">max</a>(bins), 0, <a href="#-max">max</a>(freqs) where bins is the return<br>
value from matplotlib.matplotlib.mlab.specgram<br>
* See help(psd) for information on the other keyword arguments.<br>
Return value is (Pxx, freqs, bins, im), where<br>
bins are the time points the spectrogram is calculated over<br>
freqs is an array of frequencies<br>
Pxx is a len(times) x len(freqs) array of power<br>
im is a matplotlib.image.AxesImage.<br>
Note: If x is real (i.e. non-complex) only the positive spectrum is<br>
shown. If x is complex both positive and negative parts of the<br>
spectrum are shown.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-spectral"><strong>spectral</strong></a>()</dt><dd><tt>set the default colormap to spectral and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-spring"><strong>spring</strong></a>()</dt><dd><tt>set the default colormap to spring and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-spy"><strong>spy</strong></a>(*args, **kwargs)</dt><dd><tt><a href="#-spy">spy</a>(Z) plots the sparsity pattern of the 2-D array Z<br>
If precision is None, any non-zero value will be plotted;<br>
else, values of absolute(Z)>precision will be plotted.<br>
The array will be plotted as it would be printed, with<br>
the first index (row) increasing down and the second<br>
index (column) increasing to the right.<br>
By default aspect is 'equal' so that each array element<br>
occupies a square space; set the aspect kwarg to 'auto'<br>
to allow the plot to fill the plot box, or to any scalar<br>
number to specify the aspect ratio of an array element<br>
directly.<br>
Two plotting styles are available: image or marker. Both<br>
are available for full arrays, but only the marker style<br>
works for scipy.sparse.spmatrix instances.<br>
If marker and markersize are None, an image will be<br>
returned and any remaining kwargs are passed to imshow;<br>
else, a Line2D object will be returned with the value<br>
of marker determining the marker type, and any remaining<br>
kwargs passed to the axes plot method.<br>
If marker and markersize are None, useful kwargs include:<br>
cmap<br>
alpha<br>
See documentation for <a href="#-imshow">imshow</a>() for details.<br>
For controlling colors, e.g. cyan background and red marks, use:<br>
cmap = matplotlib.colors.ListedColormap(['c','r'])<br>
If marker or markersize is not None, useful kwargs include:<br>
marker<br>
markersize<br>
color<br>
See documentation for <a href="#-plot">plot</a>() for details.<br>
Useful values for marker include:<br>
's' square (default)<br>
'o' circle<br>
'.' point<br>
',' pixel<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-stem"><strong>stem</strong></a>(*args, **kwargs)</dt><dd><tt>STEM(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')<br>
A stem plot plots vertical lines (using linefmt) at each x location<br>
from the baseline to y, and places a marker there using markerfmt. A<br>
horizontal line at 0 is is plotted using basefmt<br>
Return value is (markerline, stemlines, baseline) .<br>
See<br>
<a href="http://www.mathworks.com/access/helpdesk/help/techdoc/ref/stem.html">http://www.mathworks.com/access/helpdesk/help/techdoc/ref/stem.html</a><br>
for details and examples/stem_plot.py for a demo.<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-subplot"><strong>subplot</strong></a>(*args, **kwargs)</dt><dd><tt>Create a subplot command, creating axes with<br>
<br>
<a href="#-subplot">subplot</a>(numRows, numCols, plotNum)<br>
<br>
where plotNum=1 is the first plot number and increasing plotNums<br>
fill rows first. <a href="#-max">max</a>(plotNum)==numRows*numCols<br>
<br>
You can leave out the commas if numRows<=numCols<=plotNum<10, as<br>
in<br>
<br>
<a href="#-subplot">subplot</a>(211) # 2 rows, 1 column, first (upper) plot<br>
<br>
<a href="#-subplot">subplot</a>(111) is the default axis<br>
<br>
The background color of the subplot can be specified via keyword<br>
argument 'axisbg', which takes a color string or gdk.Color as value, as in<br>
<br>
<a href="#-subplot">subplot</a>(211, axisbg='y')<br>
<br>
See help(axes) for additional information on axes and subplot<br>
keyword arguments.<br>
<br>
New subplots that overlap old will delete the old axes. If you do<br>
not want this behavior, use fig.add_subplot or the axes command. Eg<br>
<br>
from pylab import *<br>
<a href="#-plot">plot</a>([1,2,3]) # implicitly creates <a href="#-subplot">subplot</a>(111)<br>
<a href="#-subplot">subplot</a>(211) # overlaps, <a href="#-subplot">subplot</a>(111) is killed<br>
<a href="#-plot">plot</a>(<a href="#-rand">rand</a>(12), <a href="#-rand">rand</a>(12))</tt></dd></dl>
<dl><dt><a name="-subplot_tool"><strong>subplot_tool</strong></a>(targetfig<font color="#909090">=None</font>)</dt><dd><tt>Launch a subplot tool window for targetfig (default gcf)<br>
<br>
A matplotlib.widgets.SubplotTool instance is returned</tt></dd></dl>
<dl><dt><a name="-subplots_adjust"><strong>subplots_adjust</strong></a>(*args, **kwargs)</dt><dd><tt><a href="#-subplots_adjust">subplots_adjust</a>(left=None, bottom=None, right=None, top=None,<br>
wspace=None, hspace=None)<br>
<br>
Tune the subplot layout via the figure.SubplotParams mechanism.<br>
The parameter meanings (and suggested defaults) are<br>
<br>
left = 0.125 # the left side of the subplots of the figure<br>
right = 0.9 # the right side of the subplots of the figure<br>
bottom = 0.1 # the bottom of the subplots of the figure<br>
top = 0.9 # the top of the subplots of the figure<br>
wspace = 0.2 # the amount of width reserved for blank space between subplots<br>
hspace = 0.2 # the amount of height reserved for white space between subplots<br>
<br>
The actual defaults are controlled by the rc file</tt></dd></dl>
<dl><dt><a name="-summer"><strong>summer</strong></a>()</dt><dd><tt>set the default colormap to summer and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-switch_backend"><strong>switch_backend</strong></a>(newbackend)</dt><dd><tt>Swtich the default backend to newbackend. This feature is<br>
EXPERIMENTAL, and is only expected to work switching to an image<br>
backend. Eg, if you have a bunch of PS scripts that you want to<br>
run from an interactive ipython session, yuo may want to switch to<br>
the PS backend before running them to avoid having a bunch of GUI<br>
windows popup. If you try to interactively switch from one GUI<br>
backend to another, you will explode.<br>
<br>
Calling this command will close all open windows.</tt></dd></dl>
<dl><dt><a name="-table"><strong>table</strong></a>(*args, **kwargs)</dt><dd><tt>TABLE(cellText=None, cellColours=None,<br>
cellLoc='right', colWidths=None,<br>
rowLabels=None, rowColours=None, rowLoc='left',<br>
colLabels=None, colColours=None, colLoc='center',<br>
loc='bottom', bbox=None):<br>
Add a table to the current axes. Returns a table instance. For<br>
finer grained control over tables, use the Table class and add it<br>
to the axes with add_table.<br>
Thanks to John Gill for providing the class and table.<br>
kwargs control the Table properties:<br>
alpha: float<br>
animated: [True | False]<br>
axes: an axes instance<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
figure: a matplotlib.figure.Figure instance<br>
fontsize: a float in points<br>
label: any string<br>
lod: [True | False]<br>
picker: [None|float|boolean|callable]<br>
transform: a matplotlib.transform transformation instance<br>
visible: [True | False]<br>
zorder: any number</tt></dd></dl>
<dl><dt><a name="-text"><strong>text</strong></a>(*args, **kwargs)</dt><dd><tt>TEXT(x, y, s, fontdict=None, **kwargs)<br>
Add text in string s to axis at location x,y (data coords)<br>
fontdict is a dictionary to override the default text properties.<br>
If fontdict is None, the defaults are determined by your rc<br>
parameters.<br>
withdash=True will create a TextWithDash instance instead<br>
of a Text instance.<br>
Individual keyword arguments can be used to override any given<br>
parameter<br>
<a href="#-text">text</a>(x, y, s, fontsize=12)<br>
The default transform specifies that text is in data coords,<br>
alternatively, you can specify text in axis coords (0,0 lower left and<br>
1,1 upper right). The example below places text in the center of the<br>
axes<br>
<a href="#-text">text</a>(0.5, 0.5,'matplotlib',<br>
horizontalalignment='center',<br>
verticalalignment='center',<br>
transform = ax.transAxes,<br>
)<br>
You can put a rectangular box around the text instance (eg to<br>
set a background color) by using the keyword bbox. bbox is a<br>
dictionary of matplotlib.patches.Rectangle properties (see help<br>
for Rectangle for a list of these). For example<br>
<a href="#-text">text</a>(x, y, s, bbox=dict(facecolor='red', alpha=0.5))<br>
Valid kwargs are Text properties<br>
alpha: float<br>
animated: [True | False]<br>
axes: an axes instance<br>
backgroundcolor: any matplotlib color<br>
bbox: rectangle prop dict plus key 'pad' which is a pad in points<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
color: any matplotlib color<br>
family: [ 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ]<br>
figure: a matplotlib.figure.Figure instance<br>
fontproperties: a matplotlib.font_manager.FontProperties instance<br>
horizontalalignment or ha: [ 'center' | 'right' | 'left' ]<br>
label: any string<br>
lod: [True | False]<br>
multialignment: ['left' | 'right' | 'center' ]<br>
name or fontname: string eg, ['Sans' | 'Courier' | 'Helvetica' ...]<br>
picker: [None|float|boolean|callable]<br>
position: (x,y)<br>
rotation: [ angle in degrees 'vertical' | 'horizontal'<br>
size or fontsize: [ size in points | relative size eg 'smaller', 'x-large' ]<br>
style or fontstyle: [ 'normal' | 'italic' | 'oblique']<br>
text: string or anything printable with '%s' conversion<br>
transform: a matplotlib.transform transformation instance<br>
variant: [ 'normal' | 'small-caps' ]<br>
verticalalignment or va: [ 'center' | 'top' | 'bottom' ]<br>
visible: [True | False]<br>
weight or fontweight: [ 'normal' | 'bold' | 'heavy' | 'light' | 'ultrabold' | 'ultralight']<br>
x: float<br>
y: float<br>
zorder: any number</tt></dd></dl>
<dl><dt><a name="-thetagrids"><strong>thetagrids</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the theta locations of the gridlines and ticklabels<br>
<br>
If no arguments are passed, return lines, labels where lines is an<br>
array of radial gridlines (Line2D instances) and labels is an<br>
array of tick labels (Text instances).<br>
<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>()<br>
<br>
Otherwise the syntax is<br>
<br>
lines, labels = THETAGRIDS(angles, labels=None, fmt='%d', frac = 1.1)<br>
<br>
set the angles at which to place the theta grids (these gridlines<br>
are equal along the theta dimension). angles is in degrees<br>
<br>
labels, if not None, is a len(angles) list of strings of the<br>
labels to use at each angle.<br>
<br>
if labels is None, the labels with be fmt%angle<br>
<br>
frac is the fraction of the polar axes radius at which to place<br>
the label (1 is the edge).Eg 1.05 isd outside the axes and 0.95<br>
is inside the axes<br>
<br>
Return value is a list of lines, labels where the lines are<br>
matplotlib.Line2D instances and the labels are matplotlib.Text<br>
instances. Note that on input the labels argument is a list of<br>
strings, and on output it is a list of Text instances<br>
<br>
Examples:<br>
<br>
# set the locations of the radial gridlines and labels<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>( range(45,360,90) )<br>
<br>
# set the locations and labels of the radial gridlines and labels<br>
lines, labels = <a href="#-thetagrids">thetagrids</a>( range(45,360,90), ('NE', 'NW', 'SW','SE') )</tt></dd></dl>
<dl><dt><a name="-title"><strong>title</strong></a>(s, *args, **kwargs)</dt><dd><tt>Set the title of the current axis to s<br>
<br>
Default font override is:<br>
override = {<br>
'fontsize' : 'medium',<br>
'verticalalignment' : 'bottom',<br>
'horizontalalignment' : 'center'<br>
}<br>
<br>
See the text docstring for information of how override and the<br>
optional args work</tt></dd></dl>
<dl><dt><a name="-twinx"><strong>twinx</strong></a>(ax<font color="#909090">=None</font>)</dt><dd><tt>Make a second axes overlay ax (or the current axes if ax is None)<br>
sharing the xaxis. The ticks for ax2 will be placed on the right,<br>
and the ax2 instance is returned. See examples/two_scales.py</tt></dd></dl>
<dl><dt><a name="-twiny"><strong>twiny</strong></a>(ax<font color="#909090">=None</font>)</dt><dd><tt>Make a second axes overlay ax (or the current axes if ax is None)<br>
sharing the yaxis. The ticks for ax2 will be placed on the top,<br>
and the ax2 instance is returned.</tt></dd></dl>
<dl><dt><a name="-vdot"><strong>vdot</strong></a>(...)</dt><dd><tt><a href="#-vdot">vdot</a>(a,b)<br>
Returns the dot product of a and b for scalars and vectors<br>
of floating point and complex types. The first argument, a, is conjugated.</tt></dd></dl>
<dl><dt><a name="-vlines"><strong>vlines</strong></a>(*args, **kwargs)</dt><dd><tt>VLINES(x, ymin, ymax, color='k')<br>
Plot vertical lines at each x from ymin to ymax. ymin or ymax can be<br>
scalars or len(x) numpy arrays. If they are scalars, then the<br>
respective values are constant, else the heights of the lines are<br>
determined by ymin and ymax<br>
colors is a line collections color args, either a single color<br>
or a len(x) list of colors<br>
linestyle is one of solid|dashed|dashdot|dotted<br>
Returns the LineCollection that was added<br>
kwargs are LineCollection properties:<br>
alpha: float or sequence of floats<br>
animated: [True | False]<br>
array: unknown<br>
axes: an axes instance<br>
clim: a length 2 sequence of floats<br>
clip_box: a matplotlib.transform.Bbox instance<br>
clip_on: [True | False]<br>
clip_path: an agg.path_storage instance<br>
cmap: a colormap<br>
color: matplotlib color arg or sequence of rgba tuples<br>
colorbar: unknown<br>
figure: a matplotlib.figure.Figure instance<br>
label: any string<br>
linestyle: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) ]<br>
linewidth: float or sequence of floats<br>
lod: [True | False]<br>
norm: unknown<br>
picker: [None|float|boolean|callable]<br>
segments: unknown<br>
transform: a matplotlib.transform transformation instance<br>
verts: unknown<br>
visible: [True | False]<br>
zorder: any number<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-winter"><strong>winter</strong></a>()</dt><dd><tt>set the default colormap to winter and apply to current image if any. See help(colormaps) for more information</tt></dd></dl>
<dl><dt><a name="-xcorr"><strong>xcorr</strong></a>(*args, **kwargs)</dt><dd><tt>XCORR(x, y, normed=False, detrend=detrend_none, usevlines=False, **kwargs):<br>
Plot the cross correlation between x and y. If normed=True,<br>
normalize the data but the cross correlation at 0-th lag. x<br>
and y are detrended by the detrend callable (default no<br>
normalization. x and y must be equal length<br>
data are plotted as <a href="#-plot">plot</a>(lags, c, **kwargs)<br>
return value is lags, c, line where lags are a length<br>
2*maxlags+1 lag vector, c is the 2*maxlags+1 auto correlation<br>
vector, and line is a Line2D instance returned by plot. The<br>
default linestyle is None and the default marker is 'o',<br>
though these can be overridden with keyword args. The cross<br>
correlation is performed with numerix cross_correlate with<br>
mode=2.<br>
If usevlines is True, Axes.vlines rather than Axes.plot is used<br>
to draw vertical lines from the origin to the acorr.<br>
Otherwise the plotstyle is determined by the kwargs, which are<br>
Line2D properties. If usevlines, the return value is lags, c,<br>
linecol, b where linecol is the LineCollection and b is the x-axis<br>
if usevlines=True, kwargs are passed onto Axes.vlines<br>
if usevlines=False, kwargs are passed onto Axes.plot<br>
maxlags is a positive integer detailing the number of lags to show.<br>
The default value of None will return all (2*len(x)-1) lags.<br>
See the respective function for documentation on valid kwargs<br>
<br>
Addition kwargs: hold = [True|False] overrides default hold state</tt></dd></dl>
<dl><dt><a name="-xlabel"><strong>xlabel</strong></a>(s, *args, **kwargs)</dt><dd><tt>Set the x axis label of the current axis to s<br>
<br>
Default override is<br>
<br>
override = {<br>
'fontsize' : 'small',<br>
'verticalalignment' : 'top',<br>
'horizontalalignment' : 'center'<br>
}<br>
<br>
See the text docstring for information of how override and<br>
the optional args work</tt></dd></dl>
<dl><dt><a name="-xlim"><strong>xlim</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the xlimits of the current axes<br>
<br>
xmin, xmax = <a href="#-xlim">xlim</a>() : return the current xlim<br>
<a href="#-xlim">xlim</a>( (xmin, xmax) ) : set the xlim to xmin, xmax<br>
<a href="#-xlim">xlim</a>( xmin, xmax ) : set the xlim to xmin, xmax<br>
<br>
If you do not specify args, you can pass the xmin and xmax as<br>
kwargs, eg<br>
<br>
<a href="#-xlim">xlim</a>(xmax=3) # adjust the max leaving min unchanged<br>
<a href="#-xlim">xlim</a>(xmin=1) # adjust the min leaving max unchanged<br>
<br>
The new axis limits are returned as a length 2 tuple</tt></dd></dl>
<dl><dt><a name="-xticks"><strong>xticks</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the xlimits of the current ticklocs, labels<br>
<br>
# return locs, labels where locs is an array of tick locations and<br>
# labels is an array of tick labels.<br>
locs, labels = <a href="#-xticks">xticks</a>()<br>
<br>
# set the locations of the xticks<br>
<a href="#-xticks">xticks</a>( arange(6) )<br>
<br>
# set the locations and labels of the xticks<br>
<a href="#-xticks">xticks</a>( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )<br>
<br>
The keyword args, if any, are text properties; see text for more<br>
information on text properties.</tt></dd></dl>
<dl><dt><a name="-ylabel"><strong>ylabel</strong></a>(s, *args, **kwargs)</dt><dd><tt>Set the y axis label of the current axis to s<br>
<br>
Defaults override is<br>
<br>
override = {<br>
'fontsize' : 'small',<br>
'verticalalignment' : 'center',<br>
'horizontalalignment' : 'right',<br>
'rotation'='vertical' : }<br>
<br>
See the text docstring for information of how override and the<br>
optional args work</tt></dd></dl>
<dl><dt><a name="-ylim"><strong>ylim</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the ylimits of the current axes<br>
<br>
ymin, ymax = <a href="#-ylim">ylim</a>() : return the current ylim<br>
<a href="#-ylim">ylim</a>( (ymin, ymax) ) : set the ylim to ymin, ymax<br>
<a href="#-ylim">ylim</a>( ymin, ymax ) : set the ylim to ymin, ymax<br>
<br>
If you do not specify args, you can pass the ymin and ymax as<br>
kwargs, eg<br>
<br>
<a href="#-ylim">ylim</a>(ymax=3) # adjust the max leaving min unchanged<br>
<a href="#-ylim">ylim</a>(ymin=1) # adjust the min leaving max unchanged<br>
<br>
The new axis limits are returned as a length 2 tuple</tt></dd></dl>
<dl><dt><a name="-yticks"><strong>yticks</strong></a>(*args, **kwargs)</dt><dd><tt>Set/Get the ylimits of the current ticklocs, labels<br>
<br>
# return locs, labels where locs is an array of tick locations and<br>
# labels is an array of tick labels.<br>
locs, labels = <a href="#-yticks">yticks</a>()<br>
<br>
# set the locations of the yticks<br>
<a href="#-yticks">yticks</a>( arange(6) )<br>
<br>
# set the locations and labels of the yticks<br>
<a href="#-yticks">yticks</a>( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )<br>
<br>
The keyword args, if any, are text properties; see text for more<br>
information on text properties.</tt></dd></dl>
</td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#55aa55">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Data</strong></big></font></td></tr>
<tr><td bgcolor="#55aa55"><tt> </tt></td><td> </td>
<td width="100%"><strong>Character</strong> = 'c'<br>
<strong>Complex</strong> = 'D'<br>
<strong>Complex0</strong> = 'F'<br>
<strong>Complex16</strong> = 'F'<br>
<strong>Complex32</strong> = 'F'<br>
<strong>Complex64</strong> = 'D'<br>
<strong>Complex8</strong> = 'F'<br>
<strong>DAILY</strong> = 3<br>
<strong>FR</strong> = FR<br>
<strong>Float</strong> = 'd'<br>
<strong>Float0</strong> = 'f'<br>
<strong>Float16</strong> = 'f'<br>
<strong>Float32</strong> = 'f'<br>
<strong>Float64</strong> = 'd'<br>
<strong>Float8</strong> = 'f'<br>
<strong>HOURLY</strong> = 4<br>
<strong>Int</strong> = 'l'<br>
<strong>Int0</strong> = 'b'<br>
<strong>Int16</strong> = 'h'<br>
<strong>Int32</strong> = 'i'<br>
<strong>Int8</strong> = 'b'<br>
<strong>LittleEndian</strong> = True<br>
<strong>MINUTELY</strong> = 5<br>
<strong>MO</strong> = MO<br>
<strong>MONTHLY</strong> = 1<br>
<strong>NewAxis</strong> = None<br>
<strong>PyObject</strong> = 'O'<br>
<strong>SA</strong> = SA<br>
<strong>SECONDLY</strong> = 6<br>
<strong>SU</strong> = SU<br>
<strong>TH</strong> = TH<br>
<strong>TU</strong> = TU<br>
<strong>UInt</strong> = 'u'<br>
<strong>UInt16</strong> = 'H'<br>
<strong>UInt32</strong> = 'I'<br>
<strong>UInt8</strong> = 'B'<br>
<strong>UnsignedInt16</strong> = 'H'<br>
<strong>UnsignedInt32</strong> = 'I'<br>
<strong>UnsignedInt8</strong> = 'B'<br>
<strong>UnsignedInteger</strong> = 'u'<br>
<strong>WE</strong> = WE<br>
<strong>WEEKLY</strong> = 2<br>
<strong>YEARLY</strong> = 0<br>
<strong>__dates_all__</strong> = ('date2num', 'num2date', 'drange', 'epoch2num', 'num2epoch', 'mx2num', 'DateFormatter', 'IndexDateFormatter', 'DateLocator', 'RRuleLocator', 'YearLocator', 'MonthLocator', 'WeekdayLocator', 'DayLocator', 'HourLocator', 'MinuteLocator', 'SecondLocator', 'rrule', 'MO', 'TU', ...)<br>
<strong>absolute</strong> = <ufunc 'absolute'><br>
<strong>add</strong> = <ufunc 'add'><br>
<strong>arccos</strong> = <ufunc 'arccos'><br>
<strong>arccosh</strong> = <ufunc 'arccosh'><br>
<strong>arcsin</strong> = <ufunc 'arcsin'><br>
<strong>arcsinh</strong> = <ufunc 'arcsinh'><br>
<strong>arctan</strong> = <ufunc 'arctan'><br>
<strong>arctan2</strong> = <ufunc 'arctan2'><br>
<strong>arctanh</strong> = <ufunc 'arctanh'><br>
<strong>bitwise_and</strong> = <ufunc 'bitwise_and'><br>
<strong>bitwise_or</strong> = <ufunc 'bitwise_or'><br>
<strong>bitwise_xor</strong> = <ufunc 'bitwise_xor'><br>
<strong>ceil</strong> = <ufunc 'ceil'><br>
<strong>colorbar_doc</strong> = '<font color="#c040c0">\n</font>Add a colorbar to a plot.<font color="#c040c0">\n\n</font>Function signatures:...e, do not use any of the<font color="#c040c0">\n</font>axes properties kwargs.<font color="#c040c0">\n</font>'<br>
<strong>conjugate</strong> = <ufunc 'conjugate'><br>
<strong>cos</strong> = <ufunc 'cos'><br>
<strong>cosh</strong> = <ufunc 'cosh'><br>
<strong>divide</strong> = <ufunc 'divide'><br>
<strong>divide_safe</strong> = <ufunc 'divide'><br>
<strong>e</strong> = 2.7182818284590451<br>
<strong>equal</strong> = <ufunc 'equal'><br>
<strong>exp</strong> = <ufunc 'exp'><br>
<strong>fabs</strong> = <ufunc 'fabs'><br>
<strong>floor</strong> = <ufunc 'floor'><br>
<strong>floor_divide</strong> = <ufunc 'floor_divide'><br>
<strong>fmod</strong> = <ufunc 'fmod'><br>
<strong>greater</strong> = <ufunc 'greater'><br>
<strong>greater_equal</strong> = <ufunc 'greater_equal'><br>
<strong>hypot</strong> = <ufunc 'hypot'><br>
<strong>invert</strong> = <ufunc 'invert'><br>
<strong>left_shift</strong> = <ufunc 'left_shift'><br>
<strong>less</strong> = <ufunc 'less'><br>
<strong>less_equal</strong> = <ufunc 'less_equal'><br>
<strong>log</strong> = <ufunc 'log'><br>
<strong>log10</strong> = <ufunc 'log10'><br>
<strong>logical_and</strong> = <ufunc 'logical_and'><br>
<strong>logical_not</strong> = <ufunc 'logical_not'><br>
<strong>logical_or</strong> = <ufunc 'logical_or'><br>
<strong>logical_xor</strong> = <ufunc 'logical_xor'><br>
<strong>maximum</strong> = <ufunc 'maximum'><br>
<strong>minimum</strong> = <ufunc 'minimum'><br>
<strong>multiply</strong> = <ufunc 'multiply'><br>
<strong>negative</strong> = <ufunc 'negative'><br>
<strong>not_equal</strong> = <ufunc 'not_equal'><br>
<strong>pi</strong> = 3.1415926535897931<br>
<strong>power</strong> = <ufunc 'power'><br>
<strong>rcParams</strong> = {'axes.axisbelow': False, 'axes.edgecolor': 'k', 'axes.facecolor': 'w', 'axes.formatter.limits': (-7, 7), 'axes.grid': False, 'axes.hold': True, 'axes.labelcolor': 'k', 'axes.labelsize': 12, 'axes.linewidth': 1.0, 'axes.titlesize': 14, ...}<br>
<strong>rcParamsDefault</strong> = {'axes.axisbelow': False, 'axes.edgecolor': 'k', 'axes.facecolor': 'w', 'axes.formatter.limits': (-7, 7), 'axes.grid': False, 'axes.hold': True, 'axes.labelcolor': 'k', 'axes.labelsize': 12, 'axes.linewidth': 1.0, 'axes.titlesize': 14, ...}<br>
<strong>remainder</strong> = <ufunc 'remainder'><br>
<strong>right_shift</strong> = <ufunc 'right_shift'><br>
<strong>sign</strong> = <ufunc 'sign'><br>
<strong>sin</strong> = <ufunc 'sin'><br>
<strong>sinh</strong> = <ufunc 'sinh'><br>
<strong>sqrt</strong> = <ufunc 'sqrt'><br>
<strong>subtract</strong> = <ufunc 'subtract'><br>
<strong>tan</strong> = <ufunc 'tan'><br>
<strong>tanh</strong> = <ufunc 'tanh'><br>
<strong>true_divide</strong> = <ufunc 'true_divide'><br>
<strong>typecodes</strong> = {'Character': 'c', 'Complex': 'FD', 'Float': 'fd', 'Integer': 'bhil', 'UnsignedInteger': 'BHI'}<br>
<strong>which</strong> = ('numpy', 'rc')</td></tr></table>
@footer@
