m[c @`s' dZddlmZmZmZmZddlZddlmZm Z m Z ddl Z ddl Z ddl Z ddlZddlZddlZddljZddlmZddlmZddlZejreZnejddd d Zd Zd Zde d Z!e e dZ"ddZ#e dZ$e dZ%dZ&e ddZ'ddZ(e e e e e e e e e e d Z)e e e e dZ*ej+j,dej-dej+j,dej-dej+j,dej-dej.e e e e e e e e dZ/ej.e e e e e e e e dZ0ej.e e e e dZ1ej.e e e e d Z2ej.e e e e d!Z3ej.e e e e d"Z4ej.e e e e e e e e e d# Z5d$Z6ej.d%d&e%ede d'e d(Z7ejdd)Z8ejdd*d%d&e%ede9e8e:d+Z;ejdd,d-Z<ejdd.d/Z=ejdd0Z>ejdd1Z?ejdd2Z@ejdd3eAfd4YZBejdd5d6d7d8d9d:fd;ZCejdd<ZDejddd=ZEejdd>d?ZFejdd@d@d6d6d6dAZGejddBZHejddCdDZIejddEdFZJejddGZKejddHZLejde%edIZMejddJZNejOdKZPdLZQejddMdNZRejdddOdPZSejddQZTejdddRdSZUejdddTdUZVejdddVd&dWZWejddXe e dYZXejddZd&d[e d\ZYejdd&dd]ZZejdd^d_Z[ejdd`ejOdadbZ\ejddcZ]ejdddZ^ejddedfZ_ejddgdhZ`ejde diZaejddjZbejddkZcejddlZdejddmZeejddne dodpdqZfejddrd6e dsZgejddtdddue e dve e:e:e:dw ZhejddxeAfdyYZiejddzeifd{YZjejdd|eifd}YZkejdd~ekfdYZlejddeifdYZmejddeifdYZnejddelfdYZoejddelfdYZpejddelfdYZqejddddeifdYZrejdddderfdYZsejde dZtejddZuejddde dde dZvejddddue dve e9dZwejdddddZxejddde:dZyejddZzejde dZ{deAfdYZ|ejddZ}ejddZ~ejddZejddZejddddZejddZejddZejddae dZejddZejddZejddZejddZdS(u Numerical python functions written for compatibility with MATLAB commands with the same names. MATLAB compatible functions --------------------------- :func:`cohere` Coherence (normalized cross spectral density) :func:`csd` Cross spectral density using Welch's average periodogram :func:`detrend` Remove the mean or best fit line from an array :func:`find` Return the indices where some condition is true; numpy.nonzero is similar but more general. :func:`griddata` Interpolate irregularly distributed data to a regular grid. :func:`prctile` Find the percentiles of a sequence :func:`prepca` Principal Component Analysis :func:`psd` Power spectral density using Welch's average periodogram :func:`rk4` A 4th order runge kutta integrator for 1D or ND systems :func:`specgram` Spectrogram (spectrum over segments of time) Miscellaneous functions ----------------------- Functions that don't exist in MATLAB, but are useful anyway: :func:`cohere_pairs` Coherence over all pairs. This is not a MATLAB function, but we compute coherence a lot in my lab, and we compute it for a lot of pairs. This function is optimized to do this efficiently by caching the direct FFTs. :func:`rk4` A 4th order Runge-Kutta ODE integrator in case you ever find yourself stranded without scipy (and the far superior scipy.integrate tools) :func:`contiguous_regions` Return the indices of the regions spanned by some logical mask :func:`cross_from_below` Return the indices where a 1D array crosses a threshold from below :func:`cross_from_above` Return the indices where a 1D array crosses a threshold from above :func:`complex_spectrum` Return the complex-valued frequency spectrum of a signal :func:`magnitude_spectrum` Return the magnitude of the frequency spectrum of a signal :func:`angle_spectrum` Return the angle (wrapped phase) of the frequency spectrum of a signal :func:`phase_spectrum` Return the phase (unwrapped angle) of the frequency spectrum of a signal :func:`detrend_mean` Remove the mean from a line. :func:`demean` Remove the mean from a line. This function is the same as :func:`detrend_mean` except for the default *axis*. :func:`detrend_linear` Remove the best fit line from a line. :func:`detrend_none` Return the original line. :func:`stride_windows` Get all windows in an array in a memory-efficient manner :func:`stride_repeat` Repeat an array in a memory-efficient manner :func:`apply_window` Apply a window along a given axis record array helper functions ----------------------------- A collection of helper methods for numpyrecord arrays .. _htmlonly: See :ref:`misc-examples-index` :func:`rec2txt` Pretty print a record array :func:`rec2csv` Store record array in CSV file :func:`csv2rec` Import record array from CSV file with type inspection :func:`rec_append_fields` Adds field(s)/array(s) to record array :func:`rec_drop_fields` Drop fields from record array :func:`rec_join` Join two record arrays on sequence of fields :func:`recs_join` A simple join of multiple recarrays using a single column as a key :func:`rec_groupby` Summarize data by groups (similar to SQL GROUP BY) :func:`rec_summarize` Helper code to filter rec array fields into new fields For the rec viewer functions(e rec2csv), there are a bunch of Format objects you can pass into the functions that will do things like color negative values red, set percent formatting and scaling, etc. Example usage:: r = csv2rec('somefile.csv', checkrows=0) formatd = dict( weight = FormatFloat(2), change = FormatPercent(2), cost = FormatThousands(2), ) rec2excel(r, 'test.xls', formatd=formatd) rec2csv(r, 'test.csv', formatd=formatd) scroll = rec2gtk(r, formatd=formatd) win = gtk.Window() win.set_size_request(600,800) win.add(scroll) win.show_all() gtk.main() i(tabsolute_importtdivisiontprint_functiontunicode_literalsN(tmaptxrangetzip(t docstring(tPathu2.2t alternativeu!numpy.logspace or numpy.geomspacecC`s.tjtjtj|tj||S(uH Return N values logarithmically spaced between xmin and xmax. (tnptexptlinspacetlog(txmintxmaxtN((s.lib/python2.7/site-packages/matplotlib/mlab.pytlogspacescC`stjt||S(u Return x times the hanning window of len(x). See Also -------- :func:`window_none` :func:`window_none` is another window algorithm. (R thanningtlen(tx((s.lib/python2.7/site-packages/matplotlib/mlab.pytwindow_hannings cC`s|S(u No window function; simply return x. See Also -------- :func:`window_hanning` :func:`window_hanning` is another window algorithm. ((R((s.lib/python2.7/site-packages/matplotlib/mlab.pyt window_nones c C`sTtj|}|jdks-|jdkr<tdn|d|jkrbtd|nt|j}|j|}tj|rt ||krtdn|}n|tj |d|j }|jdkr|r|||fS||Sn|j}|dd}t ||d|} |rH| ||fS| |SdS( u Apply the given window to the given 1D or 2D array along the given axis. Parameters ---------- x : 1D or 2D array or sequence Array or sequence containing the data. window : function or array. Either a function to generate a window or an array with length *x*.shape[*axis*] axis : integer The axis over which to do the repetition. Must be 0 or 1. The default is 0 return_window : bool If true, also return the 1D values of the window that was applied iiu only 1D or 2D arrays can be useduaxis(=%s) out of boundsuFThe len(window) must be the same as the shape of x for the chosen axistdtypetaxisN( R tasarraytndimt ValueErrortlisttshapetpoptcbooktiterableRtonesRt stride_repeat( RtwindowRt return_windowtxshapet xshapetargt windowValst xshapeothert otheraxist windowValsRep((s.lib/python2.7/site-packages/matplotlib/mlab.pyt apply_windows,   cC`st|d ks|dkr.t|dtd|S|dkrPt|dtd|S|dkrrt|dtd|St|tjrtd|nt |std|nt j |}|d k r|d |j krtd |n|d kr|j d ks(| r2|j d kr2||Sy||d|SWn't k rot j|d|d |SXd S(u Return x with its trend removed. Parameters ---------- x : array or sequence Array or sequence containing the data. key : [ 'default' | 'constant' | 'mean' | 'linear' | 'none'] or function Specifies the detrend algorithm to use. 'default' is 'mean', which is the same as :func:`detrend_mean`. 'constant' is the same. 'linear' is the same as :func:`detrend_linear`. 'none' is the same as :func:`detrend_none`. The default is 'mean'. See the corresponding functions for more details regarding the algorithms. Can also be a function that carries out the detrend operation. axis : integer The axis along which to do the detrending. See Also -------- :func:`detrend_mean` :func:`detrend_mean` implements the 'mean' algorithm. :func:`detrend_linear` :func:`detrend_linear` implements the 'linear' algorithm. :func:`detrend_none` :func:`detrend_none` implements the 'none' algorithm. uconstantumeanudefaulttkeyRulinearunoneu`Unknown value for key %s, must be one of: 'default', 'constant', 'mean', 'linear', or a functioniuaxis(=%s) out of boundsitarrN(uconstantumeanudefault(tNonetdetrendt detrend_meantdetrend_lineart detrend_nonet isinstancetsixt string_typesRtcallableR RRt TypeErrortapply_along_axis(RR,R((s.lib/python2.7/site-packages/matplotlib/mlab.pyR/s*     1  cC`st|d|S(uN Return x minus its mean along the specified axis. Parameters ---------- x : array or sequence Array or sequence containing the data Can have any dimensionality axis : integer The axis along which to take the mean. See numpy.mean for a description of this argument. See Also -------- :func:`delinear` :func:`denone` :func:`delinear` and :func:`denone` are other detrend algorithms. :func:`detrend_mean` This function is the same as :func:`detrend_mean` except for the default *axis*. R(R0(RR((s.lib/python2.7/site-packages/matplotlib/mlab.pytdemeanUscC`stj|}|dk rA|d|jkrAtd|n|js`tjdd|jS|dks|dks|jdkr||j|Stdg|j}tj ||<||j||S(u Return x minus the mean(x). Parameters ---------- x : array or sequence Array or sequence containing the data Can have any dimensionality axis : integer The axis along which to take the mean. See numpy.mean for a description of this argument. See Also -------- :func:`demean` This function is the same as :func:`demean` except for the default *axis*. :func:`detrend_linear` :func:`detrend_none` :func:`detrend_linear` and :func:`detrend_none` are other detrend algorithms. :func:`detrend` :func:`detrend` is a wrapper around all the detrend algorithms. iuaxis(=%s) out of boundsgRiN( R RR.RRtarrayRtmeantslicetnewaxis(RRtind((s.lib/python2.7/site-packages/matplotlib/mlab.pyR0qs ' cC`s|S(u{ Return x: no detrending. Parameters ---------- x : any object An object containing the data axis : integer This parameter is ignored. It is included for compatibility with detrend_mean See Also -------- :func:`denone` This function is the same as :func:`denone` except for the default *axis*, which has no effect. :func:`detrend_mean` :func:`detrend_linear` :func:`detrend_mean` and :func:`detrend_linear` are other detrend algorithms. :func:`detrend` :func:`detrend` is a wrapper around all the detrend algorithms. ((RR((s.lib/python2.7/site-packages/matplotlib/mlab.pyR2scC`stj|}|jdkr-tdn|jsLtjdd|jStj|jdt}tj ||dd}|d|d}|j ||j }||||S( u Return x minus best fit line; 'linear' detrending. Parameters ---------- y : 0-D or 1-D array or sequence Array or sequence containing the data axis : integer The axis along which to take the mean. See numpy.mean for a description of this argument. See Also -------- :func:`delinear` This function is the same as :func:`delinear` except for the default *axis*. :func:`detrend_mean` :func:`detrend_none` :func:`detrend_mean` and :func:`detrend_none` are other detrend algorithms. :func:`detrend` :func:`detrend` is a wrapper around all the detrend algorithms. iuy cannot have ndim > 1gRtbiasi(ii(ii( R RRRR:RtarangetsizetfloattcovR;(tyRtCtbta((s.lib/python2.7/site-packages/matplotlib/mlab.pyR1s cC`s|d krd}n||kr0tdn|dkrKtdntj|}|jdkrxtdn|dkr|dkr|dkr|tjS|tjjSn||jkrtdnt|}t|}||}|dkrC||j d||f}|j d||j df}n9|j d|||f}||j d|j df}tj j j |d|d |S( u~ Get all windows of x with length n as a single array, using strides to avoid data duplication. .. warning:: It is not safe to write to the output array. Multiple elements may point to the same piece of memory, so modifying one value may change others. Parameters ---------- x : 1D array or sequence Array or sequence containing the data. n : integer The number of data points in each window. noverlap : integer The overlap between adjacent windows. Default is 0 (no overlap) axis : integer The axis along which the windows will run. References ---------- `stackoverflow: Rolling window for 1D arrays in Numpy? `_ `stackoverflow: Using strides for an efficient moving average filter `_ iunoverlap must be less than niun cannot be less than 1u%only 1-dimensional arrays can be usedu(n cannot be greater than the length of xiRtstridesN(R.RR RRR=t transposeRAtintRRHtlibt stride_trickst as_strided(RtntnoverlapRtstepRRH((s.lib/python2.7/site-packages/matplotlib/mlab.pytstride_windowss0!          !cC`s|dkrtdntj|}|jdkrHtdn|dkr|dkrmtj|Stj|jSn|dkrtdnt|}|dkr||jf}d|jdf}n"|j|f}|jddf}tj j j |d|d|S( u Repeat the values in an array in a memory-efficient manner. Array x is stacked vertically n times. .. warning:: It is not safe to write to the output array. Multiple elements may point to the same piece of memory, so modifying one value may change others. Parameters ---------- x : 1D array or sequence Array or sequence containing the data. n : integer The number of time to repeat the array. axis : integer The axis along which the data will run. References ---------- `stackoverflow: Repeat NumPy array without replicating data? `_ iiuaxis must be 0 or 1u%only 1-dimensional arrays can be usedun cannot be less than 1RRH(ii( RR RRt atleast_2dtTRJRARHRKRLRM(RRNRRRH((s.lib/python2.7/site-packages/matplotlib/mlab.pyR"2s$       c C`s|dkrt} n ||k} |dkr6d}n|dkrKd}n|dkr`t}n|dkrut}n|dkrd}n| dks| dkrd} n| dkrtd | n| r| dkrtd ntj|}| stj|}n|dks+|dkrLtj|rCd }qkd }n|dkrktd|nt||krt|} tj ||f}d|| )n| rt||krt|} tj ||f}d|| )n|dkr|}n| dkrt } n| dkr1t} n|d kru|} |drb|ddd}n |d}d}n>|d kr|dr|dd} n|dd} d}nt |||dd}t ||dd}t ||dddt\}}tjj|d|ddd| ddf}tjj|d|| }| st |||}t ||dd}t ||dd}tjj|d|ddd| ddf}tj||}n| dkrtj||}n| dkr1tj|tj|j}nR| dksI| d kr[tj|}n(| dkr|tj|j}n| dkr |dstddd}ntddd}||c|9<| r||}|tj|dj}q |tj|jd}ntj|dt||dd|||}|d krtj|||| f}tj||dddf|d|ddffd}n|ds|dcd9= signal length (=%d).RRDR`RaRbR#RORcRdReRfucomplexN(R.RtwarningstwarnRpRq( RR`RaR/R#RORcRdReRfRrRlRo((s.lib/python2.7/site-packages/matplotlib/mlab.pytspecgrams C         uwCoherence is calculated by averaging over *NFFT* length segments. Your signal is too short for your choice of *NFFT*. iiudefaultc  C`st|d|kr%ttnt||||||||| \} } t||||||||| \} } t|||||||||| \} } tj| d| | }|| fS(uH The coherence between *x* and *y*. Coherence is the normalized cross spectral density: .. math:: C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}} Parameters ---------- x, y Array or sequence containing the data %(Spectral)s %(PSD)s noverlap : integer The number of points of overlap between blocks. The default value is 0 (no overlap). Returns ------- The return value is the tuple (*Cxy*, *f*), where *f* are the frequencies of the coherence vector. For cohere, scaling the individual densities by the sampling frequency has no effect, since the factors cancel out. See Also -------- :func:`psd`, :func:`csd` : For information about the methods used to compute :math:`P_{xy}`, :math:`P_{xx}` and :math:`P_{yy}`. i(RRt _coh_errorRzRxR R[(RRDR`RaR/R#RORcRdReRytftPyyR{tCxy((s.lib/python2.7/site-packages/matplotlib/mlab.pytcoheres&cG`sdS(N((targs((s.lib/python2.7/site-packages/matplotlib/mlab.pytdonothing_callback@suscipy.signal.coherencec $C`s|j\} } | |kr^|} tj|| f|j}| |d| ddf<~ n|j\} } t} x.|D]&\}}| j|| j|q}Wt| }tj|r|}n|dd}tj |rt||kr t dn|}n|tj ||j}t t d| |d||}t|}i}i}i}t|}tjj|d}x| D]}|||dtj||fdtj}xf|D]^}|||||||f}|||}tjj|| ||ddf coherence vector for that pair. i.e., ``Cxy[(i,j) = cohere(X[:,i], X[:,j])``. Number of dictionary keys is ``len(ij)``. Phase : dictionary of phases of the cross spectral density at each frequency for each pair. Keys are (*i*, *j*). freqs : vector of frequencies, equal in length to either the coherence or phase vectors for any (*i*, *j*) key. e.g., to make a coherence Bode plot:: subplot(211) plot( freqs, Cxy[(12,19)]) subplot(212) plot( freqs, Phase[(12,19)]) For a large number of pairs, :func:`cohere_pairs` can be much more efficient than just calling :func:`cohere` for each pair, because it caches most of the intensive computations. If :math:`N` is the number of pairs, this function is :math:`O(N)` for most of the heavy lifting, whereas calling cohere for each pair is :math:`O(N^2)`. However, because of the caching, it is also more memory intensive, making 2 additional complex arrays with approximately the same number of elements as *X*. See :file:`test/cohere_pairs_test.py` in the src tree for an example script that shows that this :func:`cohere_pairs` and :func:`cohere` give the same results for a given pair. See Also -------- :func:`psd` For information about the methods used to compute :math:`P_{xy}`, :math:`P_{xx}` and :math:`P_{yy}`. Niiu.The length of the window must be equal to NFFTiu Cacheing FFTsRRi uComputing coherences(RR tzerosRtsettaddRRURR RR!RRtrangetlinalgtnormtcomplex_RXRZtdivideR;R[tarctan2timagRqR@($tXtijR`RaR/R#ROtpreferSpeedOverMemorytprogressCallbackt returnPxxtnumRowstnumColsttmpt allColumnstitjtNcolsRhR'R>t numSlicest FFTSlicest FFTConjSlicesRytslicestnormValtiColtSlicestiSlicet thisSliceRtPhasetcountRR{Rl((s.lib/python2.7/site-packages/matplotlib/mlab.pyt cohere_pairsEsvJ      $    "* 3     *&uscipy.stats.entropycC`stj||\}}|jt}tj|tj|d}tj|t|}|d|d}dtj|tj |tj |}|S(u Return the entropy of the data in *y* in units of nat. .. math:: -\sum p_i \ln(p_i) where :math:`p_i` is the probability of observing *y* in the :math:`i^{th}` bin of *bins*. *bins* can be a number of bins or a range of bins; see :func:`numpy.histogram`. Compare *S* with analytic calculation for a Gaussian:: x = mu + sigma * randn(200000) Sanalytic = 0.5 * ( 1.0 + log(2*pi*sigma**2.0) ) iig( R t histogramtastypeRBttaketnonzeroRRR\R (RDtbinsRNtptdeltatS((s.lib/python2.7/site-packages/matplotlib/mlab.pytentropys-uscipy.stats.norm.pdfcG`sI|\}}dtjdtj|tjdd|||dS(uCReturn the normal pdf evaluated at *x*; args provides *mu*, *sigma*g?ig(R tsqrttpiR (RRtmutsigma((s.lib/python2.7/site-packages/matplotlib/mlab.pytnormpdfs cC`stjtj|\}|S(u1Return the indices where ravel(condition) is true(R Rtravel(t conditiontres((s.lib/python2.7/site-packages/matplotlib/mlab.pytfindscC`s>tj|}t|dkr.tjgS|dkjd}t|dkritjt|St|t|krtjgStjt|df|j}||dd+tj|}|dkjd}|dkjd}||t ||kjdd}tj||||}|S(u Return the indices of the longest stretch of contiguous ones in *x*, assuming *x* is a vector of zeros and ones. If there are two equally long stretches, pick the first. iiii( R RRR:RR@RRtdifftmax(RR>RDtdiftuptdnR((s.lib/python2.7/site-packages/matplotlib/mlab.pytlongest_contiguous_oness   " (cC`s t|S(u!alias for longest_contiguous_ones(R(R((s.lib/python2.7/site-packages/matplotlib/mlab.pyt longest_ones+stPCAcB`s8eZedZddZdZedZRS(c C`s |j\}}||kr*tdn|||_|_|jdd|_|jdd|_||_|j |}||_ t j j |dt\}}}||_t j||jj}||_|d|_|jt|} | | j|_dS(u compute the SVD of a and store data for PCA. Use project to project the data onto a reduced set of dimensions Parameters ---------- a : np.ndarray A numobservations x numdims array standardize : bool True if input data are to be standardized. If False, only centering will be carried out. Attributes ---------- a A centered unit sigma version of input ``a``. numrows, numcols The dimensions of ``a``. mu A numdims array of means of ``a``. This is the vector that points to the origin of PCA space. sigma A numdims array of standard deviation of ``a``. fracs The proportion of variance of each of the principal components. s The actual eigenvalues of the decomposition. Wt The weight vector for projecting a numdims point or array into PCA space. Y A projected into PCA space. Notes ----- The factor loadings are in the ``Wt`` factor, i.e., the factor loadings for the first principal component are given by ``Wt[0]``. This row is also the first eigenvector. u5we assume data in a is organized with numrows>numcolsRit full_matricesiN(Rt RuntimeErrortnumrowstnumcolsR;RtstdRt standardizetcenterRGR RtsvdRWtWttdotRStYtsRR\tfracs( tselfRGRRNtmtURtVhRtvars((s.lib/python2.7/site-packages/matplotlib/mlab.pyt__init__3s 0   !   gcC`stj|}|jd|jkr;td|jntj|j|j|jj}|j |k}|j dkr|dd|f}n ||}|S(uq project x onto the principle axes, dropping any axes where fraction of varianceg eDgTg2E5 ?g"PYM?gzQݿg= the 25th and < 50th percentile, ... and 3 indicates the value is above the 75th percentile cutoff. *p* is either an array of percentiles in [0..100] or a scalar which indicates how many quantiles of data you want ranked. gY@iiidu/percentiles should be in range 0..100, not 0..1( RR R R@RRtminRRt searchsorted(RRtptiles((s.lib/python2.7/site-packages/matplotlib/mlab.pyt prctile_ranks 6cC`stj|t}|rA||jdd|jdd}nR||jddddtjf}||jddddtjf}|S(u Return the matrix *M* with each row having zero mean and unit std. If *dim* = 1 operate on columns instead of rows. (*dim* is opposite to the numpy axis kwarg.) RiiN(R RRBR;RR=(tMtdim((s.lib/python2.7/site-packages/matplotlib/mlab.pyt center_matrixs )))uscipy.integrate.odec C`swyt|}Wn,tk r>tjt|ft}nXtjt||ft}||d`_ at mathworld. ii(R RRR ( RRtsigmaxtsigmaytmuxtmuytsigmaxytXmutYmutrhotztdenom((s.lib/python2.7/site-packages/matplotlib/mlab.pytbivariate_normalTs  :*cC`s1tj|j\}}||||||fS(u. *Z* and *Cond* are *M* x *N* matrices. *Z* are data and *Cond* is a boolean matrix where some condition is satisfied. Return value is (*x*, *y*, *z*) where *x* and *y* are the indices into *Z* and *z* are the values of *Z* at those indices. *x*, *y*, and *z* are 1D arrays. (R tindicesR(tZtCondRR((s.lib/python2.7/site-packages/matplotlib/mlab.pyt get_xyz_wheregs g?cC`stj||fd}xmtt|||D]Q}tjjd|d}tjjd|d}tjj|||f array. Works like :func:`map`, but it returns an array. This is just a convenient shorthand for ``numpy.array(map(...))``. (R R:RR(tfnR((s.lib/python2.7/site-packages/matplotlib/mlab.pytamap scC`s#tjtjtj|dS(uP Return the root mean square of all the elements of *a*, flattened out. i(R RR;R[(RG((s.lib/python2.7/site-packages/matplotlib/mlab.pytrms_flat+sunumpy.linalg.norm(a, ord=1)cC`stjtj|S(u Return the *l1* norm of *a*, flattened out. Implemented as a separate function (not a call to :func:`norm` for speed). (R R\R[(RG((s.lib/python2.7/site-packages/matplotlib/mlab.pytl1norm3sunumpy.linalg.norm(a, ord=2)cC`s#tjtjtj|dS(u Return the *l2* norm of *a*, flattened out. Implemented as a separate function (not a call to :func:`norm` for speed). i(R RR\R[(RG((s.lib/python2.7/site-packages/matplotlib/mlab.pytl2norm=su numpy.linalg.norm(a.flat, ord=p)cC`sH|dkr"tjtj|Stjtj||d|SdS(u norm(a,p=2) -> l-p norm of a.flat Return the l-p norm of *a*, considered as a flat array. This is NOT a true matrix norm, since arrays of arbitrary rank are always flattened. *p* can be a number or the string 'Infinity' to get the L-infinity norm. uInfinityiN(R RR[R\(RGR((s.lib/python2.7/site-packages/matplotlib/mlab.pyt norm_flatGs u numpy.arangecK`s|jdd|ddk}|dkr?|d}d}n|dkrTd}ny |d}||||}Wn2tk rttj||||}nXtj|||S(u frange([start,] stop[, step, keywords]) -> array of floats Return a numpy ndarray containing a progression of floats. Similar to :func:`numpy.arange`, but defaults to a closed interval. ``frange(x0, x1)`` returns ``[x0, x0+1, x0+2, ..., x1]``; *start* defaults to 0, and the endpoint *is included*. This behavior is different from that of :func:`range` and :func:`numpy.arange`. This is deliberate, since :func:`frange` will probably be more useful for generating lists of points for function evaluation, and endpoints are often desired in this use. The usual behavior of :func:`range` can be obtained by setting the keyword *closed* = 0, in this case, :func:`frange` basically becomes :func:numpy.arange`. When *step* is given, it specifies the increment (or decrement). All arguments can be floating point numbers. ``frange(x0,x1,d)`` returns ``[x0,x0+d,x0+2d,...,xfin]`` where *xfin* <= *x1*. :func:`frange` can also be called with the keyword *npts*. This sets the number of points the list should contain (and overrides the value *step* might have been given). :func:`numpy.arange` doesn't offer this option. Examples:: >>> frange(3) array([ 0., 1., 2., 3.]) >>> frange(3,closed=0) array([ 0., 1., 2.]) >>> frange(1,6,2) array([1, 3, 5]) or 1,3,5,7, depending on floating point vagueries >>> frange(1,6.5,npts=5) array([ 1. , 2.375, 3.75 , 5.125, 6.5 ]) uclosediigg?unptsN(t setdefaultR.tKeyErrorRJR troundR@(txinitxfinRtkwtendpointtnpts((s.lib/python2.7/site-packages/matplotlib/mlab.pytfrangeYs*       %unumpy.identityulcC`s`|dk r|}ntj|f||}x+t|D]}|f|}d||tthisrtfunctoutnametattrstfuncstoutnamesRu((s.lib/python2.7/site-packages/matplotlib/mlab.pyt rec_groupbyw s#   3  cC`st|jj}g|D]}||^q}xD|D]<\}}}|j||jtj|||q6Wtjj|d|S(uH *r* is a numpy record array *summaryfuncs* is a list of (*attr*, *func*, *outname*) tuples which will apply *func* to the array *r*[attr] and assign the output to a new attribute name *outname*. The returned record array is identical to *r*, with extra arrays for each element in *summaryfuncs*. Ru(RRRuRR RRtR(Rt summaryfuncsRuRyRRRR((s.lib/python2.7/site-packages/matplotlib/mlab.pyt rec_summarize s  $uinneru1u2c'`sBttjrfnxXD]P}|jjkrPtd|n|jjkr%td|q%q%WfdfdtD}fdtD} t|} t| } | | @} tj g| D]} || ^q}tj g| D]} | | ^q}t | }d}}|dks\|dkr| j | }tj g|D]} || ^qx}t |}n|dkr| j | }tj g|D]} | | ^q}t |}nfd }gD]}||^q }fd }fd }gjj D]0}|dkrX||d|d f^qX}gjj D]0}|dkr||d|d f^q}|||}tj rg|D]!\}}|jd |f^q}ntj|} tj|||fd| }!|dk rx=|D]2}"|"| jkr[tjd|"| jfq[q[Wnx7| jD],}| |}|jdkrd|!| s c`s%i|]\}}||qS(((RRR(R(s.lib/python2.7/site-packages/matplotlib/mlab.pys s iuouteru leftouterc`sj|}|jtjkr4||jddfSj|}||kretdj|n|j|jkr||jddfS||jddfSdS(ua if name is a string key, use the larger size of r1 or r2 before merging iiu@The '{}' fields in arrays 'r1' and 'r2' must have the same dtypeN(RR4R tstring_RoRtformattnum(Rytdt1R(tr1tr2(s.lib/python2.7/site-packages/matplotlib/mlab.pytkey_desc s    c`s.|ks|jjkr"|S|SdS(uU The column name in *newrec* that corresponds to the column in *r1*. N(RRu(Ry(R,t r1postfixR(s.lib/python2.7/site-packages/matplotlib/mlab.pytmapped_r1field sc`s.|ks|jjkr"|S|SdS(uU The column name in *newrec* that corresponds to the column in *r2*. N(RRu(Ry(R,Rt r2postfix(s.lib/python2.7/site-packages/matplotlib/mlab.pytmapped_r2field siuutf-8Ru6rec_join defaults key="%s" not in new dtype names "%s"ufuiuinnertorderN(ufui(R3R4R5RRuRRRR R:Rt differenceRoRpRqRrR.RRtkindRRst iteritemsR('R,RRtjointypetdefaultsRRRytr1dtr2dtr1keystr2keyst common_keystktr1indtr2indt common_lentleft_lent right_lent left_keystleft_indt right_keyst right_indRtkeydescRRtdesctr1desctr2desct all_dtypesRRzR{tthiskeyt newrec_fieldsRR|tnewfield((R,RRRRRs.lib/python2.7/site-packages/matplotlib/mlab.pytrec_join s     &&  & &  00 1       $ uouterc`sng}tjtj|g|D]}t|^q}fd} |dkrx|D]/\} } |j| gtt| | q_WnX|dkrxI|D]>\} } d| kr|j| gtt| | qqWn|dkr%gt t |D]} d| ^q }ndj |gg|D]} d| f^q8}t j j|d|S( u Join a sequence of record arrays on single column key. This function only joins a single column of the multiple record arrays *key* is the column name that acts as a key *name* is the name of the column that we want to join *recs* is a list of record arrays to join *jointype* is a string 'inner' or 'outer' *missing* is what any missing field is replaced by *postfixes* if not None, a len recs sequence of postfixes returns a record array with columns [rowkey, name0, name1, ... namen-1]. or if postfixes [PF0, PF1, ..., PFN-1] are supplied, [rowkey, namePF0, namePF1, ... namePFN-1]. Example:: r = recs_join("date", "close", recs=[r0, r1], missing=0.) c`s|dkrS|SdS(N(R.(R(tmissingRy(s.lib/python2.7/site-packages/matplotlib/mlab.pytextractp s uouteruinneru%du,u%s%sRuN(Rtalign_iteratorsRXt attrgettertiterRRRR.RRR\R RtR(R,RytrecsRRt postfixestresultsRt aligned_itersRtrowkeyRRtpostfixRu((RRys.lib/python2.7/site-packages/matplotlib/mlab.pyt recs_joinJ s "" *  - ,$u#u,uc $`sdkrtndkr-inddl} ddl} tj|t|}dd!dY}|dkr|ntjd|}fd}||fdfd d | j j fd  | jd d d  t t j  td  td d fd  | jd d d  fdidd6dd6dd6} fd}dk}|r\xF|D]>}t|rA|dk rA|dj|rAq n|}Pq Wtd}|jdgt}x"t|D]\}}|jjjdd}djg|D]}||kr|^q}t|sd|}n|j||}|j|d}|dkr:j|d|n j||d ||,(R R(RR!((s.lib/python2.7/site-packages/matplotlib/mlab.pyR s(RRR(((s.lib/python2.7/site-packages/matplotlib/mlab.pyR( su date.strftimet FormatDatecB`s,eZdZdZdZdZRS(cC`s ||_dS(N(R(RR((s.lib/python2.7/site-packages/matplotlib/mlab.pyR scC`st|j|jfS(N(RRR(R((s.lib/python2.7/site-packages/matplotlib/mlab.pyR scC`s |dkrdS|j|jS(NuNone(R.tstrftimeR(RR((s.lib/python2.7/site-packages/matplotlib/mlab.pyR s cC`s"ddl}|jj|jS(Ni(RRRR(RRR ((s.lib/python2.7/site-packages/matplotlib/mlab.pyR s (RRRRRR(((s.lib/python2.7/site-packages/matplotlib/mlab.pyR) s   udatetime.strftimetFormatDatetimecB`seZddZdZRS(u%Y-%m-%d %H:%M:%ScC`stj||dS(N(R)R(RR((s.lib/python2.7/site-packages/matplotlib/mlab.pyR scC`sddl}|jj|S(Ni(RRR(RRR ((s.lib/python2.7/site-packages/matplotlib/mlab.pyR s (RRRR(((s.lib/python2.7/site-packages/matplotlib/mlab.pyR+ s cC`sittj6ttj6ttj6ttj6ttj6ttj 6t tj 6t tj 6}|dkrt}nxmt|jjD]Y\}}|j|}|j|}|dkr|j|jt }n||| s( RR t issubdtypet characterRJRRRtintegerRRtfloating(tcolnametcolumnR!tntypet fixed_widthtlength(RS(Rs.lib/python2.7/site-packages/matplotlib/mlab.pyt get_justifyn s&  0 9 1iic`s|\}}}}|dkr9|dt|j|S|tkr^|t|}n%|tkr|t|}n|j|SdS(Niu (RtljustRBRJtrjust(Rtjust_pad_prec_spacertjusttpadtprectspacer(R;(s.lib/python2.7/site-packages/matplotlib/mlab.pyR s uN(R.RRt is_numlikeRRRJRuRt __getitem__RRR\trstriptostlinesep(RtheaderRSR!RsRFRRAtjustify_pad_prectjustify_pad_prec_spacerRJRKRLtpjusttppadtpprecRttextlRtcolitemRttext((R;RSs.lib/python2.7/site-packages/matplotlib/mlab.pytrec2txt= s@#  E   33 cC`st|}|d kr$t}nd}|jdkrKtdnt||}g}x@t|jjD],\} } |j |t || j qsWt j |ddt\} } tj| d|} |jj}|r| j|ng}x'|D]} |j |j| |qWt}t|rV|d}t|d}nx|D]}|r|j|jj}}ntgt|}| jgt||||D]$\}}}}||||^qq]W| r| jnd S( u Save the data from numpy recarray *r* into a comma-/space-/tab-delimited file. The record array dtype names will be used for column headers. *fname*: can be a filename or a file handle. Support for gzipped files is automatic, if the filename ends in '.gz' *withheader*: if withheader is False, do not write the attribute names in the first row for formatd type FormatFloat, we override the precision to store full precision floats in the CSV file See Also -------- :func:`csv2rec` For information about *missing* and *missingd*, which can be used to fill in masked values into your CSV file. c`sfd}|S(Nc`s|r |S|SdS(N((RRtmval(R(s.lib/python2.7/site-packages/matplotlib/mlab.pyR s((RR((Rs.lib/python2.7/site-packages/matplotlib/mlab.pyt with_mask siu0rec2csv only operates on 1 dimensional recarraysuwbt return_openedRiu _fieldmaskN(RR.RRRR5RRRuRR8RRRRTRtwritertwriterowRRWRthasattrRt _fieldmaskRR(RR RR3RRt withheaderR^RRRyRtopenedR`RStmvalstismaskedRtrowmaskRRRR]((s.lib/python2.7/site-packages/matplotlib/mlab.pytrec2csv s<    $      Buscipy.interpolate.griddataunncC`stj|dtj}tj|dtj}tj|dtj}|j|jks{|j|jks{|jdkrtdntj|dtj}tj|dtj}|j|jkrtdn|jdkr |j|jkr tdn|jdkr5tj||\}}n|dkrJt}n!|dkr_t}n td tj j |}|tj j k r|j |}|j |}|j }n|ryd d lm}Wntk rtd nX|jdkr6|d d d f}|d d d f}n|jdd |jdtjtjtj|d kstjtj|d krtdntj|jd |jd ftj} tj|ddg}tj|ddg}tj|ddg}tj|ddg}tj|ddg}|j|||||| tjtj| rtj jtj| | } n| Sddlm} m} | ||} | | |} | ||Sd S(u Interpolates from a nonuniformly spaced grid to some other grid. Fits a surface of the form z = f(`x`, `y`) to the data in the (usually) nonuniformly spaced vectors (`x`, `y`, `z`), then interpolates this surface at the points specified by (`xi`, `yi`) to produce `zi`. Parameters ---------- x, y, z : 1d array_like Coordinates of grid points to interpolate from. xi, yi : 1d or 2d array_like Coordinates of grid points to interpolate to. interp : string key from {'nn', 'linear'} Interpolation algorithm, either 'nn' for natural neighbor, or 'linear' for linear interpolation. Returns ------- 2d float array Array of values interpolated at (`xi`, `yi`) points. Array will be masked is any of (`xi`, `yi`) are outside the convex hull of (`x`, `y`). Notes ----- If `interp` is 'nn' (the default), uses natural neighbor interpolation based on Delaunay triangulation. This option is only available if the mpl_toolkits.natgrid module is installed. This can be downloaded from https://github.com/matplotlib/natgrid. The (`xi`, `yi`) grid must be regular and monotonically increasing in this case. If `interp` is 'linear', linear interpolation is used via matplotlib.tri.LinearTriInterpolator. Instead of using `griddata`, more flexible functionality and other interpolation options are available using a matplotlib.tri.Triangulation and a matplotlib.tri.TriInterpolator. Riu*x, y and z must be equal-length 1-D arraysuDxi and yi must be arrays with the same number of dimensions (1 or 2)iu9if xi and yi are 2D arrays, they must have the same shapeunnulinearuinterp keyword must be one of 'linear' (for linear interpolation) or 'nn' (for natural neighbor interpolation). Default is 'nn'.i(t_natgriduTo use interp='nn' (Natural Neighbor interpolation) in griddata, natgrid must be installed. Either install it from http://github.com/matplotlib/natgrid or use interp='linear' instead.Ntexttnulu8Output grid defined by xi,yi must be monotone increasingt requirementsuC(t TriangulationtLinearTriInterpolator( R t asanyarrayR1RRRtmeshgridRTRWRtgetmasktnomasktcompresst compressedtmpl_toolkits.natgridRjt ImportErrorRtsetitsetrRRRR1trequiretnatgriddRRjt masked_wherettriRnRo(RRDR txityitinterptuse_nn_interpolationRRjtziRnRottriangt interpolator((s.lib/python2.7/site-packages/matplotlib/mlab.pytgriddata sd,3!       <)!u numpy.interpc C`s~tj|}tj|}tj|}t|j}t||d x[-1]``, the routine tries an extrapolation. The relevance of the data obtained from this, of course, is questionable... Original implementation by Halldor Bjornsson, Icelandic Meteorolocial Office, March 2006 halldor at vedur.is Completely reworked and optimized for Python by Norbert Nemec, Institute of Theoretical Physics, University or Regensburg, April 2006 Norbert.Nemec at physik.uni-regensburg.de u!'x' and 'y' must be of same shapeiiigN(R RRBRRR.RRRRtchooseR:tsignR.(R~RRDRRRRRRMtsidxtxidxtyidxtxidxp1tyotdy1tdy2tdy1dy2((s.lib/python2.7/site-packages/matplotlib/mlab.pytstineman_interp s4,   +t GaussianKDEcB`sAeZdZddZdZdZeZdZeZ RS(u Representation of a kernel-density estimate using Gaussian kernels. Parameters ---------- dataset : array_like Datapoints to estimate from. In case of univariate data this is a 1-D array, otherwise a 2-D array with shape (# of dims, # of data). bw_method : str, scalar or callable, optional The method used to calculate the estimator bandwidth. This can be 'scott', 'silverman', a scalar constant or a callable. If a scalar, this will be used directly as `kde.factor`. If a callable, it should take a `GaussianKDE` instance as only parameter and return a scalar. If None (default), 'scott' is used. Attributes ---------- dataset : ndarray The dataset with which `gaussian_kde` was initialized. dim : int Number of dimensions. num_dp : int Number of datapoints. factor : float The bandwidth factor, obtained from `kde.covariance_factor`, with which the covariance matrix is multiplied. covariance : ndarray The covariance matrix of `dataset`, scaled by the calculated bandwidth (`kde.factor`). inv_cov : ndarray The inverse of `covariance`. Methods ------- kde.evaluate(points) : ndarray Evaluate the estimated pdf on a provided set of points. kde(points) : ndarray Same as kde.evaluate(points) c`stj|_tjjjdks<tdntjjj\__t t j }dkr~n|rdkrj _n|rdkrj_njtjr| rd_fd_n6tr_fd_n tdj_td stjtjjd dd t_tjjj_njjd _jjd _tjtjjd tjjj_ dS( Niu.`dataset` input should have multiple elements.uscottu silvermanu use constantc`sS(N(((t bw_method(s.lib/python2.7/site-packages/matplotlib/mlab.pyR<usc`s jS(N(t _bw_method((R(s.lib/python2.7/site-packages/matplotlib/mlab.pyR<xsuB`bw_method` should be 'scott', 'silverman', a scalar or a callableu _data_inv_covtrowvarR?i(!R RRtdatasetR:RARRRtnum_dpR3R4R5R.t scotts_factortcovariance_factortsilverman_factortisscalarRR6tfactorRbRCRWtdata_covarianceRtinvt data_inv_covt covariancetinv_covRtdetRt norm_factor(RRRtisString((RRs.lib/python2.7/site-packages/matplotlib/mlab.pyRes>!       cC`stj|jd|jdS(Ngi(R tpowerRR(R((s.lib/python2.7/site-packages/matplotlib/mlab.pyRscC`s-tj|j|jddd|jdS(Ng@g@gi(R RRR(R((s.lib/python2.7/site-packages/matplotlib/mlab.pyRsc C`stj|}tj|j\}}||jkrTtdj||jntj|fdt}||j krxt |j D]o}|j dd|tj f|}tj |j|}tj||ddd}|tj| }qWnxt |D]~}|j |dd|tj f}tj |j|}tj||ddd}tjtj| dd||t|}gt|D]!\}}|j|r|^qS(u *points* is a sequence of *x*, *y* points. *verts* is a sequence of *x*, *y* vertices of a polygon. Return value is a sequence of indices into points for the points that are inside the polygon. (RRtcontains_point(RtvertstpolyRMR((s.lib/python2.7/site-packages/matplotlib/mlab.pyt inside_polys cC`std||gDr(tj}nt}|j|}|j|}t|}t|}||krtdn||jd|}|jd|}|||*|||*|ddd||)||fS(u/ Given a sequence of *xs* and *ys*, return the vertices of a polygon that has a horizontal base at *xmin* and an upper bound at the *ys*. *xmin* is a scalar. Intended for use with :meth:`matplotlib.axes.Axes.fill`, e.g.,:: xv, yv = poly_below(0, x, y) ax.fill(xv, yv) cs`s$|]}t|tjjVqdS(N(R3R Rt MaskedArray(Rtvar((s.lib/python2.7/site-packages/matplotlib/mlab.pys su''xs' and 'ys' must have the same lengthiNi(RR RRRRR!(RtxstystnumpytNxRRRD((s.lib/python2.7/site-packages/matplotlib/mlab.pyt poly_belows       cC`std|||gDr+tj}nt}t|}tj|sb||j|}ntj|s||j|}n|j||dddf}|j||dddf}||fS(uC Given a sequence of *x*, *ylower* and *yupper*, return the polygon that fills the regions between them. *ylower* or *yupper* can be scalar or iterable. If they are iterable, they must be equal in length to *x*. Return value is *x*, *y* arrays for use with :meth:`matplotlib.axes.Axes.fill`. cs`s$|]}t|tjjVqdS(N(R3R RR(RR((s.lib/python2.7/site-packages/matplotlib/mlab.pys sNi(RR RRRR R!R^(RtylowertyupperRRRD((s.lib/python2.7/site-packages/matplotlib/mlab.pyt poly_betweens   ""cC`stj|d|dkS(u Tests whether first and last object in a sequence are the same. These are presumably coordinates on a polygonal curve, in which case this function tests if that curve is closed. ii(R tall(R((s.lib/python2.7/site-packages/matplotlib/mlab.pytis_closed_polygonstmessageuMoved to matplotlib.cbookcC`s tj|S(uq return a list of (ind0, ind1) such that mask[ind0:ind1].all() is True and we cover all such regions (Rtcontiguous_regions(R((s.lib/python2.7/site-packages/matplotlib/mlab.pyR%scC`sVtj|}tj|d |k|d|k@d}t|rN|dS|SdS(u return the indices into *x* where *x* crosses some threshold from below, e.g., the i's where:: x[i-1]=threshold Example code:: import matplotlib.pyplot as plt t = np.arange(0.0, 2.0, 0.1) s = np.sin(2*np.pi*t) fig, ax = plt.subplots() ax.plot(t, s, '-o') ax.axhline(0.5) ax.axhline(-0.5) ind = cross_from_below(s, 0.5) ax.vlines(t[ind], -1, 1) ind = cross_from_above(s, -0.5) ax.vlines(t[ind], -1, 1) plt.show() See Also -------- :func:`cross_from_above` and :func:`contiguous_regions` iiiN(R RRR(Rt thresholdR>((s.lib/python2.7/site-packages/matplotlib/mlab.pytcross_from_below.s !+ cC`sVtj|}tj|d |k|d|k@d}t|rN|dS|SdS(u return the indices into *x* where *x* crosses some threshold from below, e.g., the i's where:: x[i-1]>threshold and x[i]<=threshold See Also -------- :func:`cross_from_below` and :func:`contiguous_regions` iiiN(R RRR(RRR>((s.lib/python2.7/site-packages/matplotlib/mlab.pytcross_from_aboveWs + cC`s.tj|}tj||d|d|S(u Finds the length of a set of vectors in *n* dimensions. This is like the :func:`numpy.norm` function for vectors, but has the ability to work over a particular axis of the supplied array or matrix. Computes ``(sum((x_i)^P))^(1/P)`` for each ``{x_i}`` being the elements of *X* along the given axis. If *axis* is *None*, compute over all elements of *X*. Rg?(R RR\(RtPR((s.lib/python2.7/site-packages/matplotlib/mlab.pytvector_lengthsos cC`s%tj|dd}t|ddS(u Computes the distance between a set of successive points in *N* dimensions. Where *X* is an *M* x *N* array or matrix. The distances between successive rows is computed. Distance is the standard Euclidean distance. Rii(R RR(R((s.lib/python2.7/site-packages/matplotlib/mlab.pytdistances_along_curve~s cC`s1t|}tjtjdtj|fS(u Computes the distance travelled along a polygonal curve in *N* dimensions. Where *X* is an *M* x *N* array or matrix. Returns an array of length *M* consisting of the distance along the curve at each point (i.e., the rows of *X*). i(RR R^Rtcumsum(R((s.lib/python2.7/site-packages/matplotlib/mlab.pyt path_lengths c C`sf|d|||d||}}|d|||d||}} |||||| ||fS(u Converts a quadratic Bezier curve to a cubic approximation. The inputs are the *x* and *y* coordinates of the three control points of a quadratic curve, and the output is a tuple of *x* and *y* coordinates of the four control points of the cubic curve. g@g@g?gUUUUUU?gUUUUUU?gUUUUUU?gUUUUUU?(( tq0xtq0ytq1xtq1ytq2xtq2ytc1xtc1ytc2xtc2y((s.lib/python2.7/site-packages/matplotlib/mlab.pyt quad2cubics %%cC`stj|s6tj|rMt|t|krM||}||}n>t|dkr||d||d}}n td||fS(uu Offsets an array *y* by +/- an error and returns a tuple (y - err, y + err). The error term can be: * A scalar. In this case, the returned tuple is obvious. * A vector of the same length as *y*. The quantities y +/- err are computed component-wise. * A tuple of length 2. In this case, yerr[0] is the error below *y* and yerr[1] is error above *y*. For example:: from pylab import * x = linspace(0, 2*pi, num=100, endpoint=True) y = sin(x) y_minus, y_plus = mlab.offset_line(y, 0.1) plot(x, y) fill_between(x, ym, y2=yp) show() iiiuyerr must be scalar, 1xN or 2xN(RRNR RR(RDtyerrtymintymax((s.lib/python2.7/site-packages/matplotlib/mlab.pyt offset_lines    (Rt __future__RRRRR4t six.movesRRRR6RRXRQRRR tmatplotlib.cbookRt matplotlibRtmatplotlib.pathRR9tPY3RJROt deprecatedRRRR.R+R/R9R0R2R1RQR"RpRttinterpdtupdatetdedenttdedent_interpdRzRxR|R}R~RRRRRRTRWRRRRRRtobjectRRRRRR RRRRR-R0R3R R7R8R:R<R=R>R?R@RIRNRPRbRfRgRiRlRnR}R~RRRRRRRRRR R#R$R&R'R(R)R+R5R8R\RiRRRRRRRRRRRRRRRRR(((s.lib/python2.7/site-packages/matplotlib/mlab.pytsr"           8?  /  /D 7      $  @ E + / + +  W 0 ' H     9   C   $,   :       x F(* ^  )