Menu
▾
▴
[r8989]: / trunk / htdocs / matplotlib.pylab.html.template Maximize Restore History
938 lines (935 with data), 74.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> (version 1.2.0.dev5564)</font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/jdhunter/dev/lib64/python2.5/site-packages/matplotlib/pylab.py">/home/jdhunter/dev/lib64/python2.5/site-packages/matplotlib/pylab.py</a></font></td></tr></table>
<p><tt>This is a procedural interface to the matplotlib object-oriented<br>
plotting library.<br>
<br>
The following plotting commands are provided; the majority have<br>
Matlab(TM) analogs and similar argument.<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>
findobj - recursively find all objects matching some criteria<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>
plotfile - plot column data from an ASCII tab/space/comma delimited file<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>
suptitle - add a figure title<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>
logspace - a log 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>
griddata - interpolate irregularly distributed data to a regular grid<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</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.add_newdocs.html">numpy.add_newdocs</a><br>
<a href="numpy.core.defchararray.html">numpy.core.defchararray</a><br>
<a href="matplotlib.cm.html">matplotlib.cm</a><br>
<a href="numpy.ctypeslib.html">numpy.ctypeslib</a><br>
<a href="numpy.doc.html">numpy.doc</a><br>
<a href="numpy.lib.scimath.html">numpy.lib.scimath</a><br>
</td><td width="25%" valign=top><a href="numpy.fft.fftpack.html">numpy.fft.fftpack</a><br>
<a href="numpy.fft.fftpack_lite.html">numpy.fft.fftpack_lite</a><br>
<a href="numpy.fft.helper.html">numpy.fft.helper</a><br>
<a href="numpy.linalg.info.html">numpy.linalg.info</a><br>
<a href="numpy.linalg.lapack_lite.html">numpy.linalg.lapack_lite</a><br>
<a href="numpy.linalg.linalg.html">numpy.linalg.linalg</a><br>
</td><td width="25%" valign=top><a href="numpy.ma.html">numpy.ma</a><br>
<a href="math.html">math</a><br>
<a href="matplotlib.html">matplotlib</a><br>
<a href="matplotlib.mlab.html">matplotlib.mlab</a><br>
<a href="matplotlib.mpl.html">matplotlib.mpl</a><br>
<a href="numpy.html">numpy</a><br>
</td><td width="25%" valign=top><a href="matplotlib.pyplot.html">matplotlib.pyplot</a><br>
<a href="numpy.core.records.html">numpy.core.records</a><br>
<a href="sys.html">sys</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="-add_docstring"><strong>add_docstring</strong></a>(...)</dt><dd><tt>docstring(obj, docstring)<br>
<br>
Add a docstring to a built-in obj if possible.<br>
If the obj already has a docstring raise a RuntimeError<br>
If this routine does not know how to add a docstring to the object<br>
raise a TypeError</tt></dd></dl>
<dl><dt><a name="-arange"><strong>arange</strong></a>(...)</dt><dd><tt><a href="#-arange">arange</a>([start,] stop[, step,], dtype=None)<br>
<br>
For integer arguments, just like range() except it returns an array<br>
whose type can be specified by the keyword argument dtype. If dtype<br>
is not specified, the type of the result is deduced from the type of<br>
the arguments.<br>
<br>
For floating point arguments, the length of the result is ceil((stop -<br>
start)/step). This rule may result in the last element of the result<br>
being greater than stop.</tt></dd></dl>
<dl><dt><a name="-array"><strong>array</strong></a>(...)</dt><dd><tt><a href="#-array">array</a>(object, dtype=None, copy=1,order=None, subok=0,ndmin=0)<br>
<br>
Return an array from object with the specified data-type.<br>
<br>
Parameters<br>
----------<br>
object : array-like<br>
an array, any object exposing the array interface, any<br>
object whose __array__ method returns an array, or any<br>
(nested) sequence.<br>
dtype : data-type<br>
The desired data-type for the array. If not given, then<br>
the type will be determined as the minimum type required<br>
to hold the objects in the sequence. This argument can only<br>
be used to 'upcast' the array. For downcasting, use the<br>
.astype(t) method.<br>
copy : bool<br>
If true, then force a copy. Otherwise a copy will only occur<br>
if __array__ returns a copy, obj is a nested sequence, or<br>
a copy is needed to satisfy any of the other requirements<br>
order : {'C', 'F', 'A' (None)}<br>
Specify the order of the array. If order is 'C', then the<br>
array will be in C-contiguous order (last-index varies the<br>
fastest). If order is 'FORTRAN', then the returned array<br>
will be in Fortran-contiguous order (first-index varies the<br>
fastest). If order is None, then the returned array may<br>
be in either C-, or Fortran-contiguous order or even<br>
discontiguous.<br>
subok : bool<br>
If True, then sub-classes will be passed-through, otherwise<br>
the returned array will be forced to be a base-class array<br>
ndmin : int<br>
Specifies the minimum number of dimensions that the resulting<br>
array should have. 1's will be pre-pended to the shape as<br>
needed to meet this requirement.</tt></dd></dl>
<dl><dt><a name="-beta"><strong>beta</strong></a>(...)</dt><dd><tt>Beta distribution over [0, 1].<br>
<br>
<a href="#-beta">beta</a>(a, b, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-bincount"><strong>bincount</strong></a>(...)</dt><dd><tt><a href="#-bincount">bincount</a>(x,weights=None)<br>
<br>
Return the number of occurrences of each value in x.<br>
<br>
x must be a list of non-negative integers. The output, b[i],<br>
represents the number of times that i is found in x. If weights<br>
is specified, every occurrence of i at a position p contributes<br>
weights[p] instead of 1.<br>
<br>
See also: histogram, digitize, unique.</tt></dd></dl>
<dl><dt><a name="-binomial"><strong>binomial</strong></a>(...)</dt><dd><tt>Binomial distribution of n trials and p probability of success.<br>
<br>
<a href="#-binomial">binomial</a>(n, p, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-bytes"><strong>bytes</strong></a>(...)</dt><dd><tt>Return random bytes.<br>
<br>
<a href="#-bytes">bytes</a>(length) -> str</tt></dd></dl>
<dl><dt><a name="-can_cast"><strong>can_cast</strong></a>(...)</dt><dd><tt><a href="#-can_cast">can_cast</a>(from=d1, to=d2)<br>
<br>
Returns True if data type d1 can be cast to data type d2 without<br>
losing precision.</tt></dd></dl>
<dl><dt><a name="-chisquare"><strong>chisquare</strong></a>(...)</dt><dd><tt>Chi^2 distribution.<br>
<br>
<a href="#-chisquare">chisquare</a>(df, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-compare_chararrays"><strong>compare_chararrays</strong></a>(...)</dt></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>
Examples<br>
--------<br>
>>> np.<a href="#-concatenate">concatenate</a>( ([0,1,2], [5,6,7]) )<br>
<a href="#-array">array</a>([0, 1, 2, 5, 6, 7])</tt></dd></dl>
<dl><dt><a name="-digitize"><strong>digitize</strong></a>(...)</dt><dd><tt><a href="#-digitize">digitize</a>(x,bins)<br>
<br>
Return the index of the bin to which each value of x belongs.<br>
<br>
Each index i returned is such that bins[i-1] <= x < bins[i] if<br>
bins is monotonically increasing, or bins [i-1] > x >= bins[i] if<br>
bins is monotonically decreasing.<br>
<br>
Beyond the bounds of the bins 0 or len(bins) is returned as appropriate.</tt></dd></dl>
<dl><dt><a name="-dot"><strong>dot</strong></a>(...)</dt></dl>
<dl><dt><a name="-empty"><strong>empty</strong></a>(...)</dt><dd><tt><a href="#-empty">empty</a>(shape, dtype=float, order='C')<br>
<br>
Return a new array of given shape and type with all entries uninitialized.<br>
This can be faster than zeros.<br>
<br>
Parameters<br>
----------<br>
shape : tuple of integers<br>
Shape of the new array<br>
dtype : data-type<br>
The desired data-type for the array.<br>
order : {'C', 'F'}<br>
Whether to store multidimensional data in C or Fortran order.</tt></dd></dl>
<dl><dt><a name="-exponential"><strong>exponential</strong></a>(...)</dt><dd><tt>Exponential distribution.<br>
<br>
<a href="#-exponential">exponential</a>(scale=1.0, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-f"><strong>f</strong></a>(...)</dt><dd><tt>F distribution.<br>
<br>
<a href="#-f">f</a>(dfnum, dfden, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-fastCopyAndTranspose"><strong>fastCopyAndTranspose</strong></a> = _fastCopyAndTranspose(...)</dt><dd><tt>_fastCopyAndTranspose(a)</tt></dd></dl>
<dl><dt><a name="-frombuffer"><strong>frombuffer</strong></a>(...)</dt><dd><tt><a href="#-frombuffer">frombuffer</a>(buffer=, dtype=float, count=-1, offset=0)<br>
<br>
Returns a 1-d array of data type dtype from buffer.<br>
<br>
Parameters<br>
----------<br>
buffer<br>
An object that exposes the buffer interface<br>
dtype : data-type<br>
Data type of the returned array.<br>
count : int<br>
Number of items to read. -1 means all data in the buffer.<br>
offset : int<br>
Number of bytes to jump from the start of the buffer before reading<br>
<br>
Notes<br>
-----<br>
If the buffer has data that is not in machine byte-order, then<br>
use a proper data type descriptor. The data will not be<br>
byteswapped, but the array will manage it in future operations.</tt></dd></dl>
<dl><dt><a name="-fromfile"><strong>fromfile</strong></a>(...)</dt><dd><tt><a href="#-fromfile">fromfile</a>(file=, dtype=float, count=-1, sep='')<br>
<br>
Return an array of the given data type from a text or binary file.<br>
<br>
Data written using the tofile() method can be conveniently recovered using<br>
this function.<br>
<br>
Parameters<br>
----------<br>
file : file or string<br>
Open file object or string containing a file name.<br>
dtype : data-type<br>
Data type of the returned array.<br>
For binary files, it is also used to determine the size and order of<br>
the items in the file.<br>
count : int<br>
Number of items to read. -1 means all data in the whole file.<br>
sep : string<br>
Separator between items if file is a text file.<br>
Empty ("") separator means the file should be treated as binary.<br>
<br>
See also<br>
--------<br>
loadtxt : load data from text files<br>
<br>
Notes<br>
-----<br>
WARNING: This function should be used sparingly as the binary files are not<br>
platform independent. In particular, they contain no endianess or datatype<br>
information. Nevertheless it can be useful for reading in simply formatted<br>
or binary data quickly.</tt></dd></dl>
<dl><dt><a name="-fromiter"><strong>fromiter</strong></a>(...)</dt><dd><tt><a href="#-fromiter">fromiter</a>(iterable, dtype, count=-1)<br>
<br>
Return a new 1d array initialized from iterable.<br>
<br>
Parameters<br>
----------<br>
iterable<br>
Iterable object from which to obtain data<br>
dtype : data-type<br>
Data type of the returned array.<br>
count : int<br>
Number of items to read. -1 means all data in the iterable.<br>
<br>
Returns<br>
-------<br>
new_array : ndarray</tt></dd></dl>
<dl><dt><a name="-frompyfunc"><strong>frompyfunc</strong></a>(...)</dt><dd><tt><a href="#-frompyfunc">frompyfunc</a>(func, nin, nout) take an arbitrary python function that takes nin objects as input and returns nout objects and return a universal function (ufunc). This ufunc always returns PyObject arrays</tt></dd></dl>
<dl><dt><a name="-fromstring"><strong>fromstring</strong></a>(...)</dt><dd><tt><a href="#-fromstring">fromstring</a>(string, dtype=float, count=-1, sep='')<br>
<br>
Return a new 1d array initialized from the raw binary data in string.<br>
<br>
If count is positive, the new array will have count elements, otherwise its<br>
size is determined by the size of string. If sep is not empty then the<br>
string is interpreted in ASCII mode and converted to the desired number type<br>
using sep as the separator between elements (extra whitespace is ignored).<br>
ASCII integer conversions are base-10; octal and hex are not supported.</tt></dd></dl>
<dl><dt><a name="-gamma"><strong>gamma</strong></a>(...)</dt><dd><tt>Gamma distribution.<br>
<br>
<a href="#-gamma">gamma</a>(shape, scale=1.0, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-geometric"><strong>geometric</strong></a>(...)</dt><dd><tt>Geometric distribution with p being the probability of "success" on<br>
an individual trial.<br>
<br>
<a href="#-geometric">geometric</a>(p, size=None)</tt></dd></dl>
<dl><dt><a name="-get_state"><strong>get_state</strong></a>(...)</dt><dd><tt>Return a tuple representing the internal state of the generator.<br>
<br>
<a href="#-get_state">get_state</a>() -> ('MT19937', int key[624], int pos, int has_gauss, float cached_gaussian)</tt></dd></dl>
<dl><dt><a name="-getbuffer"><strong>getbuffer</strong></a>(...)</dt><dd><tt><a href="#-getbuffer">getbuffer</a>(obj [,offset[, size]])<br>
<br>
Create a buffer object from the given object referencing a slice of<br>
length size starting at offset. Default is the entire buffer. A<br>
read-write buffer is attempted followed by a read-only buffer.</tt></dd></dl>
<dl><dt><a name="-geterrobj"><strong>geterrobj</strong></a>(...)</dt><dd><tt><a href="#-geterrobj">geterrobj</a>()<br>
<br>
Used internally by `geterr`.<br>
<br>
Returns<br>
-------<br>
errobj : list<br>
Internal numpy buffer size, error mask, error callback function.</tt></dd></dl>
<dl><dt><a name="-gumbel"><strong>gumbel</strong></a>(...)</dt><dd><tt>Gumbel distribution.<br>
<br>
<a href="#-gumbel">gumbel</a>(loc=0.0, scale=1.0, size=None)</tt></dd></dl>
<dl><dt><a name="-hypergeometric"><strong>hypergeometric</strong></a>(...)</dt><dd><tt>Hypergeometric distribution.<br>
<br>
Consider an urn with ngood "good" balls and nbad "bad" balls. If one<br>
were to draw nsample balls from the urn without replacement, then<br>
the hypergeometric distribution describes the distribution of "good"<br>
balls in the sample.<br>
<br>
<a href="#-hypergeometric">hypergeometric</a>(ngood, nbad, nsample, size=None)</tt></dd></dl>
<dl><dt><a name="-inner"><strong>inner</strong></a>(...)</dt><dd><tt><a href="#-inner">inner</a>(a,b)<br>
<br>
Returns the dot product of two arrays, which has shape a.shape[:-1] +<br>
b.shape[:-1] with elements computed by the product of the elements<br>
from the last dimensions of a and b.</tt></dd></dl>
<dl><dt><a name="-int_asbuffer"><strong>int_asbuffer</strong></a>(...)</dt></dl>
<dl><dt><a name="-laplace"><strong>laplace</strong></a>(...)</dt><dd><tt>Laplace distribution.<br>
<br>
<a href="#-laplace">laplace</a>(loc=0.0, scale=1.0, size=None)</tt></dd></dl>
<dl><dt><a name="-lexsort"><strong>lexsort</strong></a>(...)</dt><dd><tt><a href="#-lexsort">lexsort</a>(keys=, axis=-1) -> array of indices. Argsort with list of keys.<br>
<br>
Perform an indirect sort using a list of keys. The first key is sorted,<br>
then the second, and so on through the list of keys. At each step the<br>
previous order is preserved when equal keys are encountered. The result is<br>
a sort on multiple keys. If the keys represented columns of a spreadsheet,<br>
for example, this would sort using multiple columns (the last key being<br>
used for the primary sort order, the second-to-last key for the secondary<br>
sort order, and so on).<br>
<br>
Parameters<br>
----------<br>
keys : (k,N) array or tuple of (N,) sequences<br>
Array containing values that the returned indices should sort, or<br>
a sequence of things that can be converted to arrays of the same shape.<br>
<br>
axis : integer<br>
Axis to be indirectly sorted. Default is -1 (i.e. last axis).<br>
<br>
Returns<br>
-------<br>
indices : (N,) integer array<br>
Array of indices that sort the keys along the specified axis.<br>
<br>
See Also<br>
--------<br>
argsort : indirect sort<br>
sort : inplace sort<br>
<br>
Examples<br>
--------<br>
>>> a = [1,5,1,4,3,6,7]<br>
>>> b = [9,4,0,4,0,4,3]<br>
>>> ind = np.<a href="#-lexsort">lexsort</a>((b,a))<br>
>>> print ind<br>
[2 0 4 3 1 5 6]<br>
>>> print np.take(a,ind)<br>
[1 1 3 4 5 6 7]<br>
>>> print np.take(b,ind)<br>
[0 9 0 4 4 4 3]</tt></dd></dl>
<dl><dt><a name="-loads"><strong>loads</strong></a>(...)</dt><dd><tt><a href="#-loads">loads</a>(string) -- Load a pickle from the given string</tt></dd></dl>
<dl><dt><a name="-logistic"><strong>logistic</strong></a>(...)</dt><dd><tt>Logistic distribution.<br>
<br>
<a href="#-logistic">logistic</a>(loc=0.0, scale=1.0, size=None)</tt></dd></dl>
<dl><dt><a name="-lognormal"><strong>lognormal</strong></a>(...)</dt><dd><tt>Log-normal distribution.<br>
<br>
Note that the mean parameter is not the mean of this distribution, but<br>
the underlying normal distribution.<br>
<br>
<a href="#-lognormal">lognormal</a>(mean, sigma) <=> exp(<a href="#-normal">normal</a>(mean, sigma))<br>
<br>
<a href="#-lognormal">lognormal</a>(mean=0.0, sigma=1.0, size=None)</tt></dd></dl>
<dl><dt><a name="-logseries"><strong>logseries</strong></a>(...)</dt><dd><tt>Logarithmic series distribution.<br>
<br>
<a href="#-logseries">logseries</a>(p, size=None)</tt></dd></dl>
<dl><dt><a name="-multinomial"><strong>multinomial</strong></a>(...)</dt><dd><tt>Multinomial distribution.<br>
<br>
<a href="#-multinomial">multinomial</a>(n, pvals, size=None) -> random values<br>
<br>
pvals is a sequence of probabilities that should sum to 1 (however, the<br>
last element is always assumed to account for the remaining probability<br>
as long as sum(pvals[:-1]) <= 1).</tt></dd></dl>
<dl><dt><a name="-multivariate_normal"><strong>multivariate_normal</strong></a>(...)</dt><dd><tt>Return an array containing multivariate normally distributed random numbers<br>
with specified mean and covariance.<br>
<br>
<a href="#-multivariate_normal">multivariate_normal</a>(mean, cov) -> random values<br>
<a href="#-multivariate_normal">multivariate_normal</a>(mean, cov, [m, n, ...]) -> random values<br>
<br>
mean must be a 1 dimensional array. cov must be a square two dimensional<br>
array with the same number of rows and columns as mean has elements.<br>
<br>
The first form returns a single 1-D array containing a multivariate<br>
normal.<br>
<br>
The second form returns an array of shape (m, n, ..., cov.shape[0]).<br>
In this case, output[i,j,...,:] is a 1-D array containing a multivariate<br>
normal.</tt></dd></dl>
<dl><dt><a name="-negative_binomial"><strong>negative_binomial</strong></a>(...)</dt><dd><tt>Negative Binomial distribution.<br>
<br>
<a href="#-negative_binomial">negative_binomial</a>(n, p, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-newbuffer"><strong>newbuffer</strong></a>(...)</dt><dd><tt><a href="#-newbuffer">newbuffer</a>(size)<br>
<br>
Return a new uninitialized buffer object of size bytes</tt></dd></dl>
<dl><dt><a name="-noncentral_chisquare"><strong>noncentral_chisquare</strong></a>(...)</dt><dd><tt>Noncentral Chi^2 distribution.<br>
<br>
<a href="#-noncentral_chisquare">noncentral_chisquare</a>(df, nonc, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-noncentral_f"><strong>noncentral_f</strong></a>(...)</dt><dd><tt>Noncentral F distribution.<br>
<br>
<a href="#-noncentral_f">noncentral_f</a>(dfnum, dfden, nonc, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-normal"><strong>normal</strong></a>(...)</dt><dd><tt>Normal distribution (mean=loc, stdev=scale).<br>
<br>
<a href="#-normal">normal</a>(loc=0.0, scale=1.0, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-packbits"><strong>packbits</strong></a>(...)</dt><dd><tt>out = numpy.<a href="#-packbits">packbits</a>(myarray, axis=None)<br>
<br>
myarray : an integer type array whose elements should be packed to bits<br>
<br>
This routine packs the elements of a binary-valued dataset into a<br>
NumPy array of type uint8 ('B') whose bits correspond to<br>
the logical (0 or nonzero) value of the input elements.<br>
The dimension over-which bit-packing is done is given by axis.<br>
The shape of the output has the same number of dimensions as the input<br>
(unless axis is None, in which case the output is 1-d).<br>
<br>
Example:<br>
>>> a = <a href="#-array">array</a>([[[1,0,1],<br>
... [0,1,0]],<br>
... [[1,1,0],<br>
... [0,0,1]]])<br>
>>> b = numpy.<a href="#-packbits">packbits</a>(a,axis=-1)<br>
>>> b<br>
<a href="#-array">array</a>([[[160],[64]],[[192],[32]]], dtype=uint8)<br>
<br>
Note that 160 = 128 + 32<br>
192 = 128 + 64</tt></dd></dl>
<dl><dt><a name="-pareto"><strong>pareto</strong></a>(...)</dt><dd><tt>Pareto distribution.<br>
<br>
<a href="#-pareto">pareto</a>(a, size=None)</tt></dd></dl>
<dl><dt><a name="-permutation"><strong>permutation</strong></a>(...)</dt><dd><tt>Given an integer, return a shuffled sequence of integers >= 0 and<br>
< x; given a sequence, return a shuffled array copy.<br>
<br>
<a href="#-permutation">permutation</a>(x)</tt></dd></dl>
<dl><dt><a name="-poisson"><strong>poisson</strong></a>(...)</dt><dd><tt>Poisson distribution.<br>
<br>
<a href="#-poisson">poisson</a>(lam=1.0, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-power"><strong>power</strong></a>(...)</dt><dd><tt>Power distribution.<br>
<br>
<a href="#-power">power</a>(a, size=None)</tt></dd></dl>
<dl><dt><a name="-putmask"><strong>putmask</strong></a>(...)</dt><dd><tt><a href="#-putmask">putmask</a>(a, mask, values)<br>
<br>
Sets a.flat[n] = values[n] for each n where mask.flat[n] is true.<br>
<br>
If values is not the same size as `a` and `mask` then it will repeat.<br>
This gives behavior different from a[mask] = values.<br>
<br>
Parameters<br>
----------<br>
a : {array_like}<br>
Array to put data into<br>
mask : {array_like}<br>
Boolean mask array<br>
values : {array_like}<br>
Values to put</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.<a href="#-random_sample">random_sample</a>(shape_tuple).</tt></dd></dl>
<dl><dt><a name="-randint"><strong>randint</strong></a>(...)</dt><dd><tt>Return random integers x such that low <= x < high.<br>
<br>
<a href="#-randint">randint</a>(low, high=None, size=None) -> random values<br>
<br>
If high is None, then 0 <= x < low.</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.<a href="#-standard_normal">standard_normal</a>(shape_tuple).</tt></dd></dl>
<dl><dt><a name="-random"><strong>random</strong></a> = random_sample(...)</dt><dd><tt>Return random floats in the half-open interval [0.0, 1.0).<br>
<br>
<a href="#-random_sample">random_sample</a>(size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-random_integers"><strong>random_integers</strong></a>(...)</dt><dd><tt>Return random integers x such that low <= x <= high.<br>
<br>
<a href="#-random_integers">random_integers</a>(low, high=None, size=None) -> random values.<br>
<br>
If high is None, then 1 <= x <= low.</tt></dd></dl>
<dl><dt><a name="-random_sample"><strong>random_sample</strong></a>(...)</dt><dd><tt>Return random floats in the half-open interval [0.0, 1.0).<br>
<br>
<a href="#-random_sample">random_sample</a>(size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-ranf"><strong>ranf</strong></a> = random_sample(...)</dt><dd><tt>Return random floats in the half-open interval [0.0, 1.0).<br>
<br>
<a href="#-random_sample">random_sample</a>(size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-rayleigh"><strong>rayleigh</strong></a>(...)</dt><dd><tt>Rayleigh distribution.<br>
<br>
<a href="#-rayleigh">rayleigh</a>(scale=1.0, size=None)</tt></dd></dl>
<dl><dt><a name="-sample"><strong>sample</strong></a> = random_sample(...)</dt><dd><tt>Return random floats in the half-open interval [0.0, 1.0).<br>
<br>
<a href="#-random_sample">random_sample</a>(size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-seed"><strong>seed</strong></a>(...)</dt><dd><tt>Seed the generator.<br>
<br>
<a href="#-seed">seed</a>(seed=None)<br>
<br>
seed can be an integer, an array (or other sequence) of integers of any<br>
length, or None. If seed is None, then RandomState will try to read data<br>
from /dev/urandom (or the Windows analogue) if available or seed from<br>
the clock otherwise.</tt></dd></dl>
<dl><dt><a name="-set_numeric_ops"><strong>set_numeric_ops</strong></a>(...)</dt><dd><tt><a href="#-set_numeric_ops">set_numeric_ops</a>(op=func, ...)<br>
<br>
Set some or all of the number methods for all array objects. Do not<br>
forget **dict can be used as the argument list. Return the functions<br>
that were replaced, which can be stored and set later.</tt></dd></dl>
<dl><dt><a name="-set_state"><strong>set_state</strong></a>(...)</dt><dd><tt>Set the state from a tuple.<br>
<br>
state = ('MT19937', int key[624], int pos, int has_gauss, float cached_gaussian)<br>
<br>
For backwards compatibility, the following form is also accepted<br>
although it is missing some information about the cached Gaussian value.<br>
<br>
state = ('MT19937', int key[624], int pos)<br>
<br>
<a href="#-set_state">set_state</a>(state)</tt></dd></dl>
<dl><dt><a name="-set_string_function"><strong>set_string_function</strong></a>(...)</dt><dd><tt><a href="#-set_string_function">set_string_function</a>(f, repr=1)<br>
<br>
Set the python function f to be the function used to obtain a pretty<br>
printable string version of an array whenever an array is printed.<br>
<a href="#-f">f</a>(M) should expect an array argument M, and should return a string<br>
consisting of the desired representation of M for printing.</tt></dd></dl>
<dl><dt><a name="-seterrobj"><strong>seterrobj</strong></a>(...)</dt><dd><tt><a href="#-seterrobj">seterrobj</a>()<br>
<br>
Used internally by `seterr`.<br>
<br>
Parameters<br>
----------<br>
errobj : list<br>
[buffer_size, error_mask, callback_func]<br>
<br>
See Also<br>
--------<br>
seterrcall</tt></dd></dl>
<dl><dt><a name="-shuffle"><strong>shuffle</strong></a>(...)</dt><dd><tt>Modify a sequence in-place by shuffling its contents.<br>
<br>
<a href="#-shuffle">shuffle</a>(x)</tt></dd></dl>
<dl><dt><a name="-standard_cauchy"><strong>standard_cauchy</strong></a>(...)</dt><dd><tt>Standard Cauchy with mode=0.<br>
<br>
<a href="#-standard_cauchy">standard_cauchy</a>(size=None)</tt></dd></dl>
<dl><dt><a name="-standard_exponential"><strong>standard_exponential</strong></a>(...)</dt><dd><tt>Standard exponential distribution (scale=1).<br>
<br>
<a href="#-standard_exponential">standard_exponential</a>(size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-standard_gamma"><strong>standard_gamma</strong></a>(...)</dt><dd><tt>Standard Gamma distribution.<br>
<br>
<a href="#-standard_gamma">standard_gamma</a>(shape, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-standard_normal"><strong>standard_normal</strong></a>(...)</dt><dd><tt>Standard Normal distribution (mean=0, stdev=1).<br>
<br>
<a href="#-standard_normal">standard_normal</a>(size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-standard_t"><strong>standard_t</strong></a>(...)</dt><dd><tt>Standard Student's t distribution with df degrees of freedom.<br>
<br>
<a href="#-standard_t">standard_t</a>(df, size=None)</tt></dd></dl>
<dl><dt><a name="-triangular"><strong>triangular</strong></a>(...)</dt><dd><tt>Triangular distribution starting at left, peaking at mode, and<br>
ending at right (left <= mode <= right).<br>
<br>
<a href="#-triangular">triangular</a>(left, mode, right, size=None)</tt></dd></dl>
<dl><dt><a name="-uniform"><strong>uniform</strong></a>(...)</dt><dd><tt>Uniform distribution over [low, high).<br>
<br>
<a href="#-uniform">uniform</a>(low=0.0, high=1.0, size=None) -> random values</tt></dd></dl>
<dl><dt><a name="-unpackbits"><strong>unpackbits</strong></a>(...)</dt><dd><tt>out = numpy.<a href="#-unpackbits">unpackbits</a>(myarray, axis=None)<br>
<br>
myarray - array of uint8 type where each element represents a bit-field<br>
that should be unpacked into a boolean output array<br>
<br>
The shape of the output array is either 1-d (if axis is None) or<br>
the same shape as the input array with unpacking done along the<br>
axis specified.</tt></dd></dl>
<dl><dt><a name="-vonmises"><strong>vonmises</strong></a>(...)</dt><dd><tt>von Mises circular distribution with mode mu and dispersion parameter<br>
kappa on [-pi, pi].<br>
<br>
<a href="#-vonmises">vonmises</a>(mu, kappa, size=None)</tt></dd></dl>
<dl><dt><a name="-wald"><strong>wald</strong></a>(...)</dt><dd><tt>Wald (inverse Gaussian) distribution.<br>
<br>
<a href="#-wald">wald</a>(mean, scale, size=None)</tt></dd></dl>
<dl><dt><a name="-weibull"><strong>weibull</strong></a>(...)</dt><dd><tt>Weibull distribution.<br>
<br>
<a href="#-weibull">weibull</a>(a, size=None)</tt></dd></dl>
<dl><dt><a name="-where"><strong>where</strong></a>(...)</dt><dd><tt><a href="#-where">where</a>(condition, x, y) or <a href="#-where">where</a>(condition)<br>
<br>
Return elements from `x` or `y`, depending on `condition`.<br>
<br>
Parameters<br>
----------<br>
condition : array of bool<br>
When True, yield x, otherwise yield y.<br>
x,y : 1-dimensional arrays<br>
Values from which to choose.<br>
<br>
Notes<br>
-----<br>
This is equivalent to<br>
<br>
[xv if c else yv for (c,xv,yv) in zip(condition,x,y)]<br>
<br>
The result is shaped like `condition` and has elements of `x`<br>
or `y` where `condition` is respectively True or False.<br>
<br>
In the special case, where only `condition` is given, the<br>
tuple condition.nonzero() is returned, instead.<br>
<br>
Examples<br>
--------<br>
>>> np.<a href="#-where">where</a>([True,False,True],[1,2,3],[4,5,6])<br>
<a href="#-array">array</a>([1, 5, 3])</tt></dd></dl>
<dl><dt><a name="-zeros"><strong>zeros</strong></a>(...)</dt><dd><tt><a href="#-zeros">zeros</a>(shape, dtype=float, order='C')<br>
<br>
Return a new array of given shape and type, filled zeros.<br>
<br>
Parameters<br>
----------<br>
shape : tuple of integers<br>
Shape of the new array<br>
dtype : data-type<br>
The desired data-type for the array.<br>
order : {'C', 'F'}<br>
Whether to store multidimensional data in C or Fortran order.</tt></dd></dl>
<dl><dt><a name="-zipf"><strong>zipf</strong></a>(...)</dt><dd><tt>Zipf distribution.<br>
<br>
<a href="#-zipf">zipf</a>(a, size=None)</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>ALLOW_THREADS</strong> = 1<br>
<strong>BUFSIZE</strong> = 10000<br>
<strong>CLIP</strong> = 0<br>
<strong>DAILY</strong> = 3<br>
<strong>ERR_CALL</strong> = 3<br>
<strong>ERR_DEFAULT</strong> = 0<br>
<strong>ERR_DEFAULT2</strong> = 2084<br>
<strong>ERR_IGNORE</strong> = 0<br>
<strong>ERR_LOG</strong> = 5<br>
<strong>ERR_PRINT</strong> = 4<br>
<strong>ERR_RAISE</strong> = 2<br>
<strong>ERR_WARN</strong> = 1<br>
<strong>FLOATING_POINT_SUPPORT</strong> = 1<br>
<strong>FPE_DIVIDEBYZERO</strong> = 1<br>
<strong>FPE_INVALID</strong> = 8<br>
<strong>FPE_OVERFLOW</strong> = 2<br>
<strong>FPE_UNDERFLOW</strong> = 4<br>
<strong>FR</strong> = FR<br>
<strong>False_</strong> = False<br>
<strong>HOURLY</strong> = 4<br>
<strong>Inf</strong> = inf<br>
<strong>Infinity</strong> = inf<br>
<strong>MAXDIMS</strong> = 32<br>
<strong>MINUTELY</strong> = 5<br>
<strong>MO</strong> = MO<br>
<strong>MONTHLY</strong> = 1<br>
<strong>NAN</strong> = nan<br>
<strong>NINF</strong> = -inf<br>
<strong>NZERO</strong> = -0.0<br>
<strong>NaN</strong> = nan<br>
<strong>PINF</strong> = inf<br>
<strong>PZERO</strong> = 0.0<br>
<strong>RAISE</strong> = 2<br>
<strong>SA</strong> = SA<br>
<strong>SECONDLY</strong> = 6<br>
<strong>SHIFT_DIVIDEBYZERO</strong> = 0<br>
<strong>SHIFT_INVALID</strong> = 9<br>
<strong>SHIFT_OVERFLOW</strong> = 3<br>
<strong>SHIFT_UNDERFLOW</strong> = 6<br>
<strong>SU</strong> = SU<br>
<strong>ScalarType</strong> = (<type 'int'>, <type 'float'>, <type 'complex'>, <type 'long'>, <type 'bool'>, <type 'str'>, <type 'unicode'>, <type 'buffer'>, <type 'numpy.int64'>, <type 'numpy.int16'>, <type 'numpy.object_'>, <type 'numpy.float128'>, <type 'numpy.uint16'>, <type 'numpy.uint32'>, <type 'numpy.complex128'>, <type 'numpy.unicode_'>, <type 'numpy.complex64'>, <type 'numpy.uint8'>, <type 'numpy.int64'>, <type 'numpy.uint64'>, ...)<br>
<strong>TH</strong> = TH<br>
<strong>TU</strong> = TU<br>
<strong>True_</strong> = True<br>
<strong>UFUNC_BUFSIZE_DEFAULT</strong> = 10000<br>
<strong>UFUNC_PYVALS_NAME</strong> = 'UFUNC_PYVALS'<br>
<strong>WE</strong> = WE<br>
<strong>WEEKLY</strong> = 2<br>
<strong>WRAP</strong> = 1<br>
<strong>YEARLY</strong> = 0<br>
<strong>__version__</strong> = '1.2.0.dev5564'<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_not</strong> = <ufunc 'invert'><br>
<strong>bitwise_or</strong> = <ufunc 'bitwise_or'><br>
<strong>bitwise_xor</strong> = <ufunc 'bitwise_xor'><br>
<strong>c_</strong> = <numpy.lib.index_tricks.CClass object at 0xd74990><br>
<strong>cast</strong> = {<type 'numpy.int64'>: <function <lambda> at 0xc...numpy.string_'>: <function <lambda> at 0xc5f050>}<br>
<strong>ceil</strong> = <ufunc 'ceil'><br>
<strong>colorbar_doc</strong> = '<font color="#c040c0">\n\n</font>Add a colorbar to a plot.<font color="#c040c0">\n\n</font>Function signatures...e, do not use any of the axes properties kwargs.<font color="#c040c0">\n</font>'<br>
<strong>conj</strong> = <ufunc 'conjugate'><br>
<strong>conjugate</strong> = <ufunc 'conjugate'><br>
<strong>cos</strong> = <ufunc 'cos'><br>
<strong>cosh</strong> = <ufunc 'cosh'><br>
<strong>degrees</strong> = <ufunc 'degrees'><br>
<strong>divide</strong> = <ufunc 'divide'><br>
<strong>e</strong> = 2.7182818284590451<br>
<strong>equal</strong> = <ufunc 'equal'><br>
<strong>exp</strong> = <ufunc 'exp'><br>
<strong>expm1</strong> = <ufunc 'expm1'><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>frexp</strong> = <ufunc 'frexp'><br>
<strong>greater</strong> = <ufunc 'greater'><br>
<strong>greater_equal</strong> = <ufunc 'greater_equal'><br>
<strong>hypot</strong> = <ufunc 'hypot'><br>
<strong>index_exp</strong> = <numpy.lib.index_tricks.IndexExpression object at 0xd74a90><br>
<strong>inf</strong> = inf<br>
<strong>infty</strong> = inf<br>
<strong>invert</strong> = <ufunc 'invert'><br>
<strong>isfinite</strong> = <ufunc 'isfinite'><br>
<strong>isinf</strong> = <ufunc 'isinf'><br>
<strong>isnan</strong> = <ufunc 'isnan'><br>
<strong>ldexp</strong> = <ufunc 'ldexp'><br>
<strong>left_shift</strong> = <ufunc 'left_shift'><br>
<strong>less</strong> = <ufunc 'less'><br>
<strong>less_equal</strong> = <ufunc 'less_equal'><br>
<strong>little_endian</strong> = True<br>
<strong>log</strong> = <ufunc 'log'><br>
<strong>log10</strong> = <ufunc 'log10'><br>
<strong>log1p</strong> = <ufunc 'log1p'><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>mgrid</strong> = <numpy.lib.index_tricks.nd_grid object at 0xd74810><br>
<strong>minimum</strong> = <ufunc 'minimum'><br>
<strong>mod</strong> = <ufunc 'remainder'><br>
<strong>modf</strong> = <ufunc 'modf'><br>
<strong>multiply</strong> = <ufunc 'multiply'><br>
<strong>nan</strong> = nan<br>
<strong>nbytes</strong> = {<type 'numpy.int64'>: 8, <type 'numpy.int16'>: ...type 'numpy.int8'>: 1, <type 'numpy.string_'>: 0}<br>
<strong>negative</strong> = <ufunc 'negative'><br>
<strong>newaxis</strong> = None<br>
<strong>not_equal</strong> = <ufunc 'not_equal'><br>
<strong>ogrid</strong> = <numpy.lib.index_tricks.nd_grid object at 0xd74850><br>
<strong>ones_like</strong> = <ufunc 'ones_like'><br>
<strong>pi</strong> = 3.1415926535897931<br>
<strong>r_</strong> = <numpy.lib.index_tricks.RClass object at 0xd74910><br>
<strong>radians</strong> = <ufunc 'radians'><br>
<strong>rcParams</strong> = {'figure.subplot.right': 0.90000000000000002, 'm...persize': 'letter', 'svg.embed_char_paths': True}<br>
<strong>rcParamsDefault</strong> = {'figure.subplot.right': 0.90000000000000002, 'm...persize': 'letter', 'svg.embed_char_paths': True}<br>
<strong>reciprocal</strong> = <ufunc 'reciprocal'><br>
<strong>remainder</strong> = <ufunc 'remainder'><br>
<strong>right_shift</strong> = <ufunc 'right_shift'><br>
<strong>rint</strong> = <ufunc 'rint'><br>
<strong>s_</strong> = <numpy.lib.index_tricks.IndexExpression object at 0xd74b10><br>
<strong>sctypeDict</strong> = {0: <type 'numpy.bool_'>, 1: <type 'numpy.int8'>, 2: <type 'numpy.uint8'>, 3: <type 'numpy.int16'>, 4: <type 'numpy.uint16'>, 5: <type 'numpy.int32'>, 6: <type 'numpy.uint32'>, 7: <type 'numpy.int64'>, 8: <type 'numpy.uint64'>, 9: <type 'numpy.int64'>, ...}<br>
<strong>sctypeNA</strong> = {'?': 'Bool', 'B': 'UInt8', 'Bool': <type 'numpy.bool_'>, 'Complex128': <type 'numpy.complex256'>, 'Complex32': <type 'numpy.complex64'>, 'Complex64': <type 'numpy.complex128'>, 'D': 'Complex64', 'F': 'Complex32', 'Float128': <type 'numpy.float128'>, 'Float32': <type 'numpy.float32'>, ...}<br>
<strong>sctypes</strong> = {'complex': [<type 'numpy.complex64'>, <type 'numpy.complex128'>, <type 'numpy.complex256'>], 'float': [<type 'numpy.float32'>, <type 'numpy.float64'>, <type 'numpy.float128'>], 'int': [<type 'numpy.int8'>, <type 'numpy.int16'>, <type 'numpy.int32'>, <type 'numpy.int64'>], 'others': [<type 'bool'>, <type 'object'>, <type 'str'>, <type 'unicode'>, <type 'numpy.void'>], 'uint': [<type 'numpy.uint8'>, <type 'numpy.uint16'>, <type 'numpy.uint32'>, <type 'numpy.uint64'>]}<br>
<strong>sign</strong> = <ufunc 'sign'><br>
<strong>signbit</strong> = <ufunc 'signbit'><br>
<strong>sin</strong> = <ufunc 'sin'><br>
<strong>sinh</strong> = <ufunc 'sinh'><br>
<strong>sqrt</strong> = <ufunc 'sqrt'><br>
<strong>square</strong> = <ufunc 'square'><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>typeDict</strong> = {0: <type 'numpy.bool_'>, 1: <type 'numpy.int8'>, 2: <type 'numpy.uint8'>, 3: <type 'numpy.int16'>, 4: <type 'numpy.uint16'>, 5: <type 'numpy.int32'>, 6: <type 'numpy.uint32'>, 7: <type 'numpy.int64'>, 8: <type 'numpy.uint64'>, 9: <type 'numpy.int64'>, ...}<br>
<strong>typeNA</strong> = {'?': 'Bool', 'B': 'UInt8', 'Bool': <type 'numpy.bool_'>, 'Complex128': <type 'numpy.complex256'>, 'Complex32': <type 'numpy.complex64'>, 'Complex64': <type 'numpy.complex128'>, 'D': 'Complex64', 'F': 'Complex32', 'Float128': <type 'numpy.float128'>, 'Float32': <type 'numpy.float32'>, ...}<br>
<strong>typecodes</strong> = {'All': '?bhilqpBHILQPfdgFDGSUVO', 'AllFloat': 'fdgFDG', 'AllInteger': 'bBhHiIlLqQpP', 'Character': 'c', 'Complex': 'FDG', 'Float': 'fdg', 'Integer': 'bhilqp', 'UnsignedInteger': 'BHILQP'}<br>
<strong>x</strong> = 'symlog'</td></tr></table>
@footer@
