@header@
 
 
matplotlib.pylab (version 1.0.4.dev4009)		index
/home/jdhunter/dev/lib/python2.5/site-packages/matplotlib/pylab.py

This is a procedural interface to the matplotlib object-oriented
plotting library.
 
The following plotting commands are provided; the majority have
Matlab(TM) analogs and similar argument.
 
_Plotting commands
  acorr     - plot the autocorrelation function
  annotate  - annotate something in the figure
  arrow     - add an arrow to the axes
  axes      - Create a new axes
  axhline   - draw a horizontal line across axes
  axvline   - draw a vertical line across axes
  axhspan   - draw a horizontal bar across axes
  axvspan   - draw a vertical bar across axes
  axis      - Set or return the current axis limits
  bar       - make a bar chart
  barh      - a horizontal bar chart
  broken_barh - a set of horizontal bars with gaps
  box       - set the axes frame on/off state
  boxplot   - make a box and whisker plot
  cla       - clear current axes
  clabel    - label a contour plot
  clf       - clear a figure window
  clim      - adjust the color limits of the current image
  close     - close a figure window
  colorbar  - add a colorbar to the current figure
  cohere    - make a plot of coherence
  contour   - make a contour plot
  contourf  - make a filled contour plot
  csd       - make a plot of cross spectral density
  delaxes   - delete an axes from the current figure
  draw      - Force a redraw of the current figure
  errorbar  - make an errorbar graph
  figlegend - make legend on the figure rather than the axes
  figimage  - make a figure image
  figtext   - add text in figure coords
  figure   - create or change active figure
  fill     - make filled polygons
  gca      - return the current axes
  gcf      - return the current figure
  gci      - get the current image, or None
  getp      - get a handle graphics property
  grid     - set whether gridding is on
  hist     - make a histogram
  hold     - set the axes hold state
  ioff     - turn interaction mode off
  ion      - turn interaction mode on
  isinteractive - return True if interaction mode is on
  imread   - load image file into array
  imshow   - plot image data
  ishold   - return the hold state of the current axes
  legend   - make an axes legend
  loglog   - a log log plot
  matshow  - display a matrix in a new figure preserving aspect
  pcolor   - make a pseudocolor plot
  pcolormesh - make a pseudocolor plot using a quadrilateral mesh
  pie      - make a pie chart
  plot     - make a line plot
  plot_date - plot dates
  plotfile  - plot column data from an ASCII tab/space/comma delimited file
  pie      - pie charts
  polar    - make a polar plot on a PolarAxes
  psd      - make a plot of power spectral density
  quiver   - make a direction field (arrows) plot
  rc       - control the default params
  rgrids   - customize the radial grids and labels for polar
  savefig  - save the current figure
  scatter  - make a scatter plot
  setp      - set a handle graphics property
  semilogx - log x axis
  semilogy - log y axis
  show     - show the figures
  specgram - a spectrogram plot
  spy      - plot sparsity pattern using markers or image
  stem     - make a stem plot
  subplot  - make a subplot (numrows, numcols, axesnum)
  subplots_adjust - change the params controlling the subplot positions of current figure
  subplot_tool - launch the subplot configuration tool
  table    - add a table to the plot
  text     - add some text at location x,y to the current axes
  thetagrids - customize the radial theta grids and labels for polar
  title    - add a title to the current axes
  xcorr   - plot the autocorrelation function of x and y
  xlim     - set/get the xlimits
  ylim     - set/get the ylimits
  xticks   - set/get the xticks
  yticks   - set/get the yticks
  xlabel   - add an xlabel to the current axes
  ylabel   - add a ylabel to the current axes
 
  autumn - set the default colormap to autumn
  bone   - set the default colormap to bone
  cool   - set the default colormap to cool
  copper - set the default colormap to copper
  flag   - set the default colormap to flag
  gray   - set the default colormap to gray
  hot    - set the default colormap to hot
  hsv    - set the default colormap to hsv
  jet    - set the default colormap to jet
  pink   - set the default colormap to pink
  prism  - set the default colormap to prism
  spring - set the default colormap to spring
  summer - set the default colormap to summer
  winter - set the default colormap to winter
  spectral - set the default colormap to spectral
 
_Event handling
 
  connect - register an event handler
  disconnect - remove a connected event handler
 
_Matrix commands
 
  cumprod   - the cumulative product along a dimension
  cumsum    - the cumulative sum along a dimension
  detrend   - remove the mean or besdt fit line from an array
  diag      - the k-th diagonal of matrix
  diff      - the n-th differnce of an array
  eig       - the eigenvalues and eigen vectors of v
  eye       - a matrix where the k-th diagonal is ones, else zero
  find      - return the indices where a condition is nonzero
  fliplr    - flip the rows of a matrix up/down
  flipud    - flip the columns of a matrix left/right
  linspace  - a linear spaced vector of N values from min to max inclusive
  logspace  - a log spaced vector of N values from min to max inclusive
  meshgrid  - repeat x and y to make regular matrices
  ones      - an array of ones
  rand      - an array from the uniform distribution [0,1]
  randn     - an array from the normal distribution
  rot90     - rotate matrix k*90 degress counterclockwise
  squeeze   - squeeze an array removing any dimensions of length 1
  tri       - a triangular matrix
  tril      - a lower triangular matrix
  triu      - an upper triangular matrix
  vander    - the Vandermonde matrix of vector x
  svd       - singular value decomposition
  zeros     - a matrix of zeros
 
_Probability
 
  levypdf   - The levy probability density function from the char. func.
  normpdf   - The Gaussian probability density function
  rand      - random numbers from the uniform distribution
  randn     - random numbers from the normal distribution
 
_Statistics
 
  corrcoef  - correlation coefficient
  cov       - covariance matrix
  amax       - the maximum along dimension m
  mean      - the mean along dimension m
  median    - the median along dimension m
  amin       - the minimum along dimension m
  norm      - the norm of vector x
  prod      - the product along dimension m
  ptp       - the max-min along dimension m
  std       - the standard deviation along dimension m
  asum       - the sum along dimension m
 
_Time series analysis
 
  bartlett  - M-point Bartlett window
  blackman  - M-point Blackman window
  cohere    - the coherence using average periodiogram
  csd       - the cross spectral density using average periodiogram
  fft       - the fast Fourier transform of vector x
  hamming   - M-point Hamming window
  hanning   - M-point Hanning window
  hist      - compute the histogram of x
  kaiser    - M length Kaiser window
  psd       - the power spectral density using average periodiogram
  sinc      - the sinc function of array x
 
_Dates
 
  date2num  - convert python datetimes to numeric representation
  drange    - create an array of numbers for date plots
  num2date  - convert numeric type (float days since 0001) to datetime
 
_Other
 
  angle     - the angle of a complex array
  load     - load ASCII data into array
  polyfit   - fit x, y to an n-th order polynomial
  polyval   - evaluate an n-th order polynomial
  roots     - the roots of the polynomial coefficients in p
  save      - save an array to an ASCII file
  trapz     - trapezoidal integration
 
__end

 
Modules
       
numpy.add_newdocs
numpy.core.defchararray
matplotlib.cm
numpy.ctypeslib
numpy.lib.scimath
numpy.fft.fftpack
numpy.fft.fftpack_lite
numpy.fft.helper
numpy.linalg.info
numpy.linalg.lapack_lite
numpy.linalg.linalg
numpy.core.ma
math
matplotlib
matplotlib.mlab
matplotlib.mpl
numpy
numpy.core.records
sys
warnings

 
Functions
       
add_docstring(...)
docstring(obj, docstring)
 
Add a docstring to a built-in obj if possible.
If the obj already has a docstring raise a RuntimeError
If this routine does not know how to add a docstring to the object
raise a TypeError
alterdot(...)
alterdot() changes all dot functions to use blas.
arange(...)
arange([start,] stop[, step,], dtype=None)
 
For integer arguments, just like range() except it returns an array
whose type can be specified by the keyword argument dtype.  If dtype
is not specified, the type of the result is deduced from the type of
the arguments.
 
For floating point arguments, the length of the result is ceil((stop -
start)/step).  This rule may result in the last element of the result
being greater than stop.
array(...)
array(object, dtype=None, copy=1,order=None, subok=0,ndmin=0)
 
Return an array from object with the specified date-type.
 
Inputs:
  object - an array, any object exposing the array interface, any
            object whose __array__ method returns an array, or any
            (nested) sequence.
  dtype  - The desired data-type for the array.  If not given, then
            the type will be determined as the minimum type required
            to hold the objects in the sequence.  This argument can only
            be used to 'upcast' the array.  For downcasting, use the
            .astype(t) method.
  copy   - If true, then force a copy.  Otherwise a copy will only occur
            if __array__ returns a copy, obj is a nested sequence, or
            a copy is needed to satisfy any of the other requirements
  order  - Specify the order of the array.  If order is 'C', then the
            array will be in C-contiguous order (last-index varies the
            fastest).  If order is 'FORTRAN', then the returned array
            will be in Fortran-contiguous order (first-index varies the
            fastest).  If order is None, then the returned array may
            be in either C-, or Fortran-contiguous order or even
            discontiguous.
  subok  - If True, then sub-classes will be passed-through, otherwise
            the returned array will be forced to be a base-class array
  ndmin  - Specifies the minimum number of dimensions that the resulting
            array should have.  1's will be pre-pended to the shape as
            needed to meet this requirement.
beta(...)
Beta distribution over [0, 1].
 
beta(a, b, size=None) -> random values
bincount(...)
bincount(x,weights=None)
 
Return the number of occurrences of each value in x.
 
x must be a list of non-negative integers.  The output, b[i],
represents the number of times that i is found in x.  If weights
is specified, every occurrence of i at a position p contributes
weights[p] instead of 1.
 
See also: histogram, digitize, unique.
binomial(...)
Binomial distribution of n trials and p probability of success.
 
binomial(n, p, size=None) -> random values
bytes(...)
Return random bytes.
 
bytes(length) -> str
can_cast(...)
can_cast(from=d1, to=d2)
 
Returns True if data type d1 can be cast to data type d2 without
losing precision.
chisquare(...)
Chi^2 distribution.
 
chisquare(df, size=None) -> random values
compare_chararrays(...)
concatenate(...)
concatenate((a1, a2, ...), axis=0)
 
Join arrays together.
 
The tuple of sequences (a1, a2, ...) are joined along the given axis
(default is the first one) into a single numpy array.
 
Example:
 
>>> concatenate( ([0,1,2], [5,6,7]) )
array([0, 1, 2, 5, 6, 7])
digitize(...)
digitize(x,bins)
 
Return the index of the bin to which each value of x belongs.
 
Each index i returned is such that bins[i-1] <= x < bins[i] if
bins is monotonically increasing, or bins [i-1] > x >= bins[i] if
bins is monotonically decreasing.
 
Beyond the bounds of the bins 0 or len(bins) is returned as appropriate.
dot(...)
dot(a,b)
Returns the dot product of a and b for arrays of floating point types.
Like the generic numpy equivalent the product sum is over
the last dimension of a and the second-to-last dimension of b.
NB: The first argument is not conjugated.
empty(...)
empty((d1,...,dn),dtype=float,order='C')
 
Return a new array of shape (d1,...,dn) and given type with all its
entries uninitialized. This can be faster than zeros.
exponential(...)
Exponential distribution.
 
exponential(scale=1.0, size=None) -> random values
f(...)
F distribution.
 
f(dfnum, dfden, size=None) -> random values
fastCopyAndTranspose = _fastCopyAndTranspose(...)
_fastCopyAndTranspose(a)
frombuffer(...)
frombuffer(buffer=, dtype=float, count=-1, offset=0)
 
Returns a 1-d array of data type dtype from buffer. The buffer
argument must be an object that exposes the buffer interface.  If
count is -1 then the entire buffer is used, otherwise, count is the
size of the output.  If offset is given then jump that far into the
buffer. If the buffer has data that is out not in machine byte-order,
than use a propert data type descriptor. The data will not be
byteswapped, but the array will manage it in future operations.
fromfile(...)
fromfile(file=, dtype=float, count=-1, sep='') -> array.
 
Required arguments:
    file -- open file object or string containing file name.
 
Keyword arguments:
    dtype -- type and order of the returned array (default float)
    count -- number of items to input (default all)
    sep -- separater between items if file is a text file (default "")
 
Return an array of the given data type from a text or binary file. The
'file' argument can be an open file or a string with the name of a file to
read from.  If 'count' == -1 the entire file is read, otherwise count is the
number of items of the given type to read in.  If 'sep' is "" it means to
read binary data from the file using the specified dtype, otherwise it gives
the separator between elements in a text file. The 'dtype' value is also
used to determine the size and order of the items in binary files.
 
 
Data written using the tofile() method can be conveniently recovered using
this function.
 
WARNING: This function should be used sparingly as the binary files are not
platform independent. In particular, they contain no endianess or datatype
information. Nevertheless it can be useful for reading in simply formatted
or binary data quickly.
fromiter(...)
fromiter(iterable, dtype, count=-1)
 
Return a new 1d array initialized from iterable. If count is
nonegative, the new array will have count elements, otherwise it's
size is determined by the generator.
frompyfunc(...)
frompyfunc(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
fromstring(...)
fromstring(string, dtype=float, count=-1, sep='')
 
Return a new 1d array initialized from the raw binary data in string.
 
If count is positive, the new array will have count elements, otherwise its
size is determined by the size of string.  If sep is not empty then the
string is interpreted in ASCII mode and converted to the desired number type
using sep as the separator between elements (extra whitespace is ignored).
gamma(...)
Gamma distribution.
 
gamma(shape, scale=1.0, size=None) -> random values
geometric(...)
Geometric distribution with p being the probability of "success" on
an individual trial.
 
geometric(p, size=None)
get_state(...)
Return a tuple representing the internal state of the generator.
 
get_state() -> ('MT19937', int key[624], int pos)
getbuffer(...)
getbuffer(obj [,offset[, size]])
 
Create a buffer object from the given object referencing a slice of
length size starting at offset.  Default is the entire buffer. A
read-write buffer is attempted followed by a read-only buffer.
geterrobj(...)
gumbel(...)
Gumbel distribution.
 
gumbel(loc=0.0, scale=1.0, size=None)
hypergeometric(...)
Hypergeometric distribution.
 
Consider an urn with ngood "good" balls and nbad "bad" balls. If one 
were to draw nsample balls from the urn without replacement, then 
the hypergeometric distribution describes the distribution of "good" 
balls in the sample.
 
hypergeometric(ngood, nbad, nsample, size=None)
inner(...)
innerproduct(a,b)
Returns the inner product of a and b for arrays of floating point types.
Like the generic NumPy equivalent the product sum is over
the last dimension of a and b.
NB: The first argument is not conjugated.
int_asbuffer(...)
interp(...)
interp(x, xp, fp, left=None, right=None)
 
Return the value of a piecewise-linear function at each value in x.
 
The piecewise-linear function, f, is defined by the known data-points fp=f(xp).
The xp points must be sorted in increasing order but this is not checked.
 
For values of x < xp[0] return the value given by left.  If left is None, then
return fp[0].
For values of x > xp[-1] return the value given by right. If right is None, then
return fp[-1].
laplace(...)
Laplace distribution.
 
laplace(loc=0.0, scale=1.0, size=None)
lexsort(...)
lexsort(keys=, axis=-1) -> array of indices. Argsort with list of keys.
 
Perform an indirect sort using a list of keys. The first key is sorted,
then the second, and so on through the list of keys. At each step the
previous order is preserved when equal keys are encountered. The result is
a sort on multiple keys.  If the keys represented columns of a spreadsheet,
for example, this would sort using multiple columns (the last key being
used for the primary sort order, the second-to-last key for the secondary
sort order, and so on).  The keys argument must be a sequence of things
that can be converted to arrays of the same shape.
 
Parameters:
 
    a : array type
        Array containing values that the returned indices should sort.
 
    axis : integer
        Axis to be indirectly sorted. None indicates that the flattened
        array should be used. Default is -1.
 
Returns:
 
    indices : integer array
        Array of indices that sort the keys along the specified axis. The
        array has the same shape as the keys.
 
SeeAlso:
 
    argsort : indirect sort
    sort : inplace sort
loads(...)
loads(string) -- Load a pickle from the given string
logistic(...)
Logistic distribution.
 
logistic(loc=0.0, scale=1.0, size=None)
lognormal(...)
Log-normal distribution.
 
Note that the mean parameter is not the mean of this distribution, but 
the underlying normal distribution.
 
    lognormal(mean, sigma) <=> exp(normal(mean, sigma))
 
lognormal(mean=0.0, sigma=1.0, size=None)
logseries(...)
Logarithmic series distribution.
 
logseries(p, size=None)
multinomial(...)
Multinomial distribution.
 
multinomial(n, pvals, size=None) -> random values
 
pvals is a sequence of probabilities that should sum to 1 (however, the
last element is always assumed to account for the remaining probability
as long as sum(pvals[:-1]) <= 1).
multivariate_normal(...)
Return an array containing multivariate normally distributed random numbers
with specified mean and covariance.
 
multivariate_normal(mean, cov) -> random values
multivariate_normal(mean, cov, [m, n, ...]) -> random values
 
mean must be a 1 dimensional array. cov must be a square two dimensional
array with the same number of rows and columns as mean has elements.
 
The first form returns a single 1-D array containing a multivariate
normal.
 
The second form returns an array of shape (m, n, ..., cov.shape[0]).
In this case, output[i,j,...,:] is a 1-D array containing a multivariate
normal.
negative_binomial(...)
Negative Binomial distribution.
 
negative_binomial(n, p, size=None) -> random values
newbuffer(...)
newbuffer(size)
 
Return a new uninitialized buffer object of size bytes
noncentral_chisquare(...)
Noncentral Chi^2 distribution.
 
noncentral_chisquare(df, nonc, size=None) -> random values
noncentral_f(...)
Noncentral F distribution.
 
noncentral_f(dfnum, dfden, nonc, size=None) -> random values
normal(...)
Normal distribution (mean=loc, stdev=scale).
 
normal(loc=0.0, scale=1.0, size=None) -> random values
pareto(...)
Pareto distribution.
 
pareto(a, size=None)
permutation(...)
Given an integer, return a shuffled sequence of integers >= 0 and 
< x; given a sequence, return a shuffled array copy.
 
permutation(x)
poisson(...)
Poisson distribution.
 
poisson(lam=1.0, size=None) -> random values
power(...)
Power distribution.
 
power(a, size=None)
putmask(...)
putmask(a, mask, values) sets a.flat[n] = values[n] for each n where
mask.flat[n] is true.  If values is not the same size of a and mask then
it will repeat.  This gives different behavior than a[mask] = values.
rand(...)
Return an array of the given dimensions which is initialized to 
random numbers from a uniform distribution in the range [0,1).
 
rand(d0, d1, ..., dn) -> random values
 
Note:  This is a convenience function. If you want an
            interface that takes a tuple as the first argument
            use numpy.random.random_sample(shape_tuple).
randint(...)
Return random integers x such that low <= x < high.
 
randint(low, high=None, size=None) -> random values
 
If high is None, then 0 <= x < low.
randn(...)
Returns zero-mean, unit-variance Gaussian random numbers in an 
array of shape (d0, d1, ..., dn).
 
randn(d0, d1, ..., dn) -> random values
 
Note:  This is a convenience function. If you want an
            interface that takes a tuple as the first argument
            use numpy.random.standard_normal(shape_tuple).
random = random_sample(...)
Return random floats in the half-open interval [0.0, 1.0).
 
random_sample(size=None) -> random values
random_integers(...)
Return random integers x such that low <= x <= high.
 
random_integers(low, high=None, size=None) -> random values.
 
If high is None, then 1 <= x <= low.
random_sample(...)
Return random floats in the half-open interval [0.0, 1.0).
 
random_sample(size=None) -> random values
ranf = random_sample(...)
Return random floats in the half-open interval [0.0, 1.0).
 
random_sample(size=None) -> random values
rayleigh(...)
Rayleigh distribution.
 
rayleigh(scale=1.0, size=None)
restoredot(...)
restoredot() restores dots to defaults.
sample = random_sample(...)
Return random floats in the half-open interval [0.0, 1.0).
 
random_sample(size=None) -> random values
seed(...)
Seed the generator.
 
seed(seed=None)
 
seed can be an integer, an array (or other sequence) of integers of any
length, or None. If seed is None, then RandomState will try to read data
from /dev/urandom (or the Windows analogue) if available or seed from
the clock otherwise.
set_numeric_ops(...)
set_numeric_ops(op=func, ...)
 
Set some or all of the number methods for all array objects.  Do not
forget **dict can be used as the argument list.  Return the functions
that were replaced, which can be stored and set later.
set_state(...)
Set the state from a tuple.
 
state = ('MT19937', int key[624], int pos)
 
set_state(state)
set_string_function(...)
set_string_function(f, repr=1)
 
Set the python function f to be the function used to obtain a pretty
printable string version of an array whenever an array is printed.
f(M) should expect an array argument M, and should return a string
consisting of the desired representation of M for printing.
seterrobj(...)
shuffle(...)
Modify a sequence in-place by shuffling its contents.
 
shuffle(x)
standard_cauchy(...)
Standard Cauchy with mode=0.
 
standard_cauchy(size=None)
standard_exponential(...)
Standard exponential distribution (scale=1).
 
standard_exponential(size=None) -> random values
standard_gamma(...)
Standard Gamma distribution.
 
standard_gamma(shape, size=None) -> random values
standard_normal(...)
Standard Normal distribution (mean=0, stdev=1).
 
standard_normal(size=None) -> random values
standard_t(...)
Standard Student's t distribution with df degrees of freedom.
 
standard_t(df, size=None)
triangular(...)
Triangular distribution starting at left, peaking at mode, and 
ending at right (left <= mode <= right).
 
triangular(left, mode, right, size=None)
uniform(...)
Uniform distribution over [low, high).
 
uniform(low=0.0, high=1.0, size=None) -> random values
vdot(...)
vdot(a,b)
Returns the dot product of a and b for scalars and vectors
of floating point and complex types.  The first argument, a, is conjugated.
vonmises(...)
von Mises circular distribution with mode mu and dispersion parameter
kappa on [-pi, pi].
 
vonmises(mu, kappa, size=None)
wald(...)
Wald (inverse Gaussian) distribution.
 
wald(mean, scale, size=None)
weibull(...)
Weibull distribution.
 
weibull(a, size=None)
where(...)
where(condition, | x, y)
 
The result is shaped like condition and has elements of x and y where
condition is respectively true or false.  If x or y are not given,
condition.nonzero() is returned.
 
To group the indices by element, rather than dimension, use
 
    transpose(where(condition))
 
instead. This always results in a 2d array, with a row of indices for
each element that satisfies the condition.
zeros(...)
zeros((d1,...,dn),dtype=float,order='C')
 
Return a new array of shape (d1,...,dn) and type typecode with all
it's entries initialized to zero.
zipf(...)
Zipf distribution.
 
zipf(a, size=None)

 
Data
        ALLOW_THREADS = 1
BUFSIZE = 10000
CLIP = 0
DAILY = 3
ERR_CALL = 3
ERR_DEFAULT = 0
ERR_DEFAULT2 = 2084
ERR_IGNORE = 0
ERR_LOG = 5
ERR_PRINT = 4
ERR_RAISE = 2
ERR_WARN = 1
FLOATING_POINT_SUPPORT = 1
FPE_DIVIDEBYZERO = 1
FPE_INVALID = 8
FPE_OVERFLOW = 2
FPE_UNDERFLOW = 4
FR = FR
False_ = False
HOURLY = 4
Inf = inf
Infinity = inf
MAXDIMS = 32
MINUTELY = 5
MO = MO
MONTHLY = 1
NAN = nan
NINF = -inf
NZERO = -0.0
NaN = nan
PINF = inf
PZERO = 0.0
RAISE = 2
SA = SA
SECONDLY = 6
SHIFT_DIVIDEBYZERO = 0
SHIFT_INVALID = 9
SHIFT_OVERFLOW = 3
SHIFT_UNDERFLOW = 6
SU = SU
ScalarType = (<type 'int'>, <type 'float'>, <type 'complex'>, <type 'long'>, <type 'bool'>, <type 'str'>, <type 'unicode'>, <type 'buffer'>, <type 'numpy.int64'>, <type 'numpy.int16'>, <type 'numpy.void'>, <type 'numpy.int32'>, <type 'numpy.complex128'>, <type 'numpy.int32'>, <type 'numpy.uint64'>, <type 'numpy.int8'>, <type 'numpy.complex192'>, <type 'numpy.float32'>, <type 'numpy.bool_'>, <type 'numpy.uint8'>, ...)
TH = TH
TU = TU
True_ = True
UFUNC_BUFSIZE_DEFAULT = 10000
UFUNC_PYVALS_NAME = 'UFUNC_PYVALS'
WE = WE
WEEKLY = 2
WRAP = 1
YEARLY = 0
__dates_all__ = ('date2num', 'num2date', 'drange', 'epoch2num', 'num2epoch', 'mx2num', 'DateFormatter', 'IndexDateFormatter', 'DateLocator', 'RRuleLocator', 'YearLocator', 'MonthLocator', 'WeekdayLocator', 'DayLocator', 'HourLocator', 'MinuteLocator', 'SecondLocator', 'rrule', 'MO', 'TU', ...)
__version__ = '1.0.4.dev4009'
absolute = <ufunc 'absolute'>
add = <ufunc 'add'>
arccos = <ufunc 'arccos'>
arccosh = <ufunc 'arccosh'>
arcsin = <ufunc 'arcsin'>
arcsinh = <ufunc 'arcsinh'>
arctan = <ufunc 'arctan'>
arctan2 = <ufunc 'arctan2'>
arctanh = <ufunc 'arctanh'>
bitwise_and = <ufunc 'bitwise_and'>
bitwise_not = <ufunc 'invert'>
bitwise_or = <ufunc 'bitwise_or'>
bitwise_xor = <ufunc 'bitwise_xor'>
c_ = <numpy.lib.index_tricks.c_class object at 0x84b71ec>
cast = {<type 'numpy.int64'>: <function <lambda> at 0x8...py.complex64'>: <function <lambda> at 0x8409f0c>}
ceil = <ufunc 'ceil'>
colorbar_doc = '\nAdd a colorbar to a plot.\n\nFunction signatures ...e, do not use any of the\naxes properties kwargs.\n'
conj = <ufunc 'conjugate'>
conjugate = <ufunc 'conjugate'>
cos = <ufunc 'cos'>
cosh = <ufunc 'cosh'>
divide = <ufunc 'divide'>
e = 2.7182818284590451
equal = <ufunc 'equal'>
exp = <ufunc 'exp'>
expm1 = <ufunc 'expm1'>
fabs = <ufunc 'fabs'>
floor = <ufunc 'floor'>
floor_divide = <ufunc 'floor_divide'>
fmod = <ufunc 'fmod'>
frexp = <ufunc 'frexp'>
greater = <ufunc 'greater'>
greater_equal = <ufunc 'greater_equal'>
hypot = <ufunc 'hypot'>
index_exp = <numpy.lib.index_tricks._index_expression_class object at 0x84b738c>
inf = inf
infty = inf
invert = <ufunc 'invert'>
isfinite = <ufunc 'isfinite'>
isinf = <ufunc 'isinf'>
isnan = <ufunc 'isnan'>
ldexp = <ufunc 'ldexp'>
left_shift = <ufunc 'left_shift'>
less = <ufunc 'less'>
less_equal = <ufunc 'less_equal'>
little_endian = True
log = <ufunc 'log'>
log10 = <ufunc 'log10'>
log1p = <ufunc 'log1p'>
logical_and = <ufunc 'logical_and'>
logical_not = <ufunc 'logical_not'>
logical_or = <ufunc 'logical_or'>
logical_xor = <ufunc 'logical_xor'>
maximum = <ufunc 'maximum'>
mgrid = <numpy.lib.index_tricks.nd_grid object at 0x84b70ec>
minimum = <ufunc 'minimum'>
mod = <ufunc 'remainder'>
modf = <ufunc 'modf'>
multiply = <ufunc 'multiply'>
nan = nan
nbytes = {<type 'numpy.int64'>: 8, <type 'numpy.int16'>: ...numpy.unicode_'>: 0, <type 'numpy.complex64'>: 8}
negative = <ufunc 'negative'>
newaxis = None
not_equal = <ufunc 'not_equal'>
ogrid = <numpy.lib.index_tricks.nd_grid object at 0x84b710c>
ones_like = <ufunc 'ones_like'>
pi = 3.1415926535897931
r_ = <numpy.lib.index_tricks.r_class object at 0x84b716c>
rcParams = {'figure.subplot.right': 0.90000000000000002, 'm...persize': 'letter', 'svg.embed_char_paths': True}
rcParamsDefault = {'figure.subplot.right': 0.90000000000000002, 'm...persize': 'letter', 'svg.embed_char_paths': True}
reciprocal = <ufunc 'reciprocal'>
remainder = <ufunc 'remainder'>
right_shift = <ufunc 'right_shift'>
rint = <ufunc 'rint'>
s_ = <numpy.lib.index_tricks._index_expression_class object at 0x84b73cc>
sctypeDict = {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.int32'>, 8: <type 'numpy.uint32'>, 9: <type 'numpy.int64'>, ...}
sctypeNA = {'?': 'Bool', 'B': 'UInt8', 'Bool': <type 'numpy.bool_'>, 'Complex32': <type 'numpy.complex64'>, 'Complex64': <type 'numpy.complex128'>, 'Complex96': <type 'numpy.complex192'>, 'D': 'Complex64', 'F': 'Complex32', 'Float32': <type 'numpy.float32'>, 'Float64': <type 'numpy.float64'>, ...}
sctypes = {'complex': [<type 'numpy.complex64'>, <type 'numpy.complex128'>, <type 'numpy.complex192'>], 'float': [<type 'numpy.float32'>, <type 'numpy.float64'>, <type 'numpy.float96'>], 'int': [<type 'numpy.int8'>, <type 'numpy.int16'>, <type 'numpy.int32'>, <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.uint32'>, <type 'numpy.uint64'>]}
sign = <ufunc 'sign'>
signbit = <ufunc 'signbit'>
sin = <ufunc 'sin'>
sinh = <ufunc 'sinh'>
sqrt = <ufunc 'sqrt'>
square = <ufunc 'square'>
subtract = <ufunc 'subtract'>
tan = <ufunc 'tan'>
tanh = <ufunc 'tanh'>
true_divide = <ufunc 'true_divide'>
typeDict = {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.int32'>, 8: <type 'numpy.uint32'>, 9: <type 'numpy.int64'>, ...}
typeNA = {'?': 'Bool', 'B': 'UInt8', 'Bool': <type 'numpy.bool_'>, 'Complex32': <type 'numpy.complex64'>, 'Complex64': <type 'numpy.complex128'>, 'Complex96': <type 'numpy.complex192'>, 'D': 'Complex64', 'F': 'Complex32', 'Float32': <type 'numpy.float32'>, 'Float64': <type 'numpy.float64'>, ...}
typecodes = {'All': '?bhilqpBHILQPfdgFDGSUVO', 'AllFloat': 'fdgFDG', 'AllInteger': 'bBhHiIlLqQpP', 'Character': 'S1', 'Complex': 'FDG', 'Float': 'fdg', 'Integer': 'bhilqp', 'UnsignedInteger': 'BHILQP'}
@footer@