:Ic/@sdZddddddddd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/g/Zd0d1kZd0d1kZd0d1kiiZd0d2klZl Z l Z l Z l Z l Z lZlZlZlZlZd0d3klZlZlZlZlZlZlZd0d4klZlZlZlZlZl Z l!Z!l"Z"l#Z#l$Z$l%Z%l&Z&l'Z'd0d5k(l)Z)l*Z*l+Z+l,Z,l-Z-d0d6k.l/Z/l0Z0d0d7k1l2Z2l3Z3d0d8k4l5Z5d0d9k6l7Z7l8Z8d0d:k6l9Z9l:Z:l;Z<d0d;k=l>Z>d0d1k?Z@d<eAeBd=ZCd<eAd>d?ZDd@ZEdAd1eBd1d1dBZGdAd1eBd1dCZHd1d1eBdDZIdEZJdFZKdGdHZLdIZMdJZNdKd0dLZOd1d1dMZ;dGdNZPed0dOZQdPZRdQdRZSd0d1kTZTeTiUdSjod0dTkVlWZXndUZYdVZZdWZ[d1dXZ\d1dYZ]d1dZZ^d1d[Z_d1d\Z`d1d]Zad1eAd^Zbd0d1kcZcd_Zddeefd`YZfd1dKdGdaZgd1dKdGdbZhdcZiddZjdeZkdfZldgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~ddddddgZmdddddddddddddddddddddddddgZndZodZpdZqdZrdZsdZtdZud1d1eBdZvd1dd0dZwdZxdZyd1dZzd1dZ{d1dZ|d1S(srestructuredtext entlogspacetlinspacetselectt piecewiset trim_zerostcopytiterabletdifftgradienttangletunwrapt sort_complextdisptuniquetextracttplacetnansumtnanmaxt nanargmaxt nanargmintnanmint vectorizetasarray_chkfinitetaveraget histogramt histogramddtbincounttdigitizetcovtcorrcoeftmsorttmediantsincthammingthanningtbartletttblackmantkaiserttrapzti0t add_newdoct add_docstringtmeshgridtdeletetinserttappendtinterpiN( tonestzerostaranget concatenatetarraytasarrayt asanyarraytemptyt empty_liketndarraytaround(t ScalarTypetdottwheretnewaxistintptintegertisscalar( tpitmultiplytaddtarctan2t frompyfunctisnantcost less_equaltsqrttsintmodtexptlog10(traveltnonzerotchoosetsorttmean(t typecodestnumber(t atleast_1dt atleast_2d(tdiag(t_insertR)(RRR.(t setdiff1di2cCst|}|djotgtS|oa|djott|gS||t|d}tid|||}||d>> np.linspace(2.0, 3.0, num=5) array([ 2. , 2.25, 2.5 , 2.75, 3. ]) >>> np.linspace(2.0, 3.0, num=5, endpoint=False) array([ 2. , 2.2, 2.4, 2.6, 2.8]) >>> np.linspace(2.0, 3.0, num=5, retstep=True) (array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) Graphical illustration: >>> import matplotlib.pyplot as plt >>> N = 8 >>> y = np.zeros(N) >>> x1 = np.linspace(0, 10, N, endpoint=True) >>> x2 = np.linspace(0, 10, N, endpoint=False) >>> plt.plot(x1, y, 'o') >>> plt.plot(x2, y + 0.5, 'o') >>> plt.ylim([-0.5, 1]) >>> plt.show() iiiN(tintR3tfloatt_nxR1(tstarttstoptnumtendpointtretsteptstepty((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR#sA    g$@cCs+t||d|d|}ti||S(s, Return numbers spaced evenly on a log scale. In linear space, the sequence starts at ``base ** start`` (`base` to the power of `start`) and ends with ``base ** stop`` (see `endpoint` below). Parameters ---------- start : float ``base ** start`` is the starting value of the sequence. stop : float ``base ** stop`` is the final value of the sequence, unless `endpoint` is False. In that case, ``num + 1`` values are spaced over the interval in log-space, of which all but the last (a sequence of length ``num``) are returned. num : integer, optional Number of samples to generate. Default is 50. endpoint : boolean, optional If true, `stop` is the last sample. Otherwise, it is not included. Default is True. base : float, optional The base of the log space. The step size between the elements in ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform. Default is 10.0. Returns ------- samples : ndarray `num` samples, equally spaced on a log scale. See Also -------- arange : Similiar to linspace, with the step size specified instead of the number of samples. Note that, when used with a float endpoint, the endpoint may or may not be included. linspace : Similar to logspace, but with the samples uniformly distributed in linear space, instead of log space. Notes ----- Logspace is equivalent to the code >>> y = linspace(start, stop, num=num, endpoint=endpoint) >>> power(base, y) Examples -------- >>> np.logspace(2.0, 3.0, num=4) array([ 100. , 215.443469 , 464.15888336, 1000. ]) >>> np.logspace(2.0, 3.0, num=4, endpoint=False) array([ 100. , 177.827941 , 316.22776602, 562.34132519]) >>> np.logspace(2.0, 3.0, num=4, base=2.0) array([ 4. , 5.0396842 , 6.34960421, 8. ]) Graphical illustration: >>> import matplotlib.pyplot as plt >>> N = 10 >>> x1 = np.logspace(0.1, 1, N, endpoint=True) >>> x2 = np.logspace(0.1, 1, N, endpoint=False) >>> y = np.zeros(N) >>> plt.plot(x1, y, 'o') >>> plt.plot(x2, y + 0.5, 'o') >>> plt.ylim([-0.5, 1]) >>> plt.show() R_R`(RR\tpower(R]R^R_R`tbaseRc((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRusEcCsyt|WndSXdS(Nii(titer(Rc((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs i c Cs|tjo8tidtt|i}|dj o*|\}}||jo tdqfnt|p|djo|i |i f}ng}|D]} || dq~\}}||jo|d8}|d7}nt |||dt}nS|ot dt dnt|}t i|djio tdn|dj o t d nd } t|| i|} xAt| |i| D]*} | t|| | | !i|7} qWt| t|gg} | d | d } |o,|d |d} d |i| | |fS| |fSn|tdgjo|tjotidtnt|}|dj oEt|}t i|i|ijo t dn|i}n|i}|dj o*|\}}||jo tdqnt|p|djo|i |i f}ng}|D]} || dq[~\}}||jo|d8}|d7}nt |||d dt}n6t|}t i|djio tdn|djo t}n |i}t i|i|} d } |djouxKtdt|| D]T} t|| | | !}| t i|i|d d|i|d df7} qVWntdd|}xtdt|| D]} || | | !}|| | | !}t i|}||}||}t i|g|i f}t i|i|d d|i|d df}| ||7} qWt i| } |tjo | |fS|tjo1tt i|t!} | | | i"|fSndS(s Compute the histogram of a set of data. Parameters ---------- a : array_like Input data. bins : int or sequence of scalars, optional If `bins` is an int, it defines the number of equal-width bins in the given range (10, by default). If `bins` is a sequence, it defines the bin edges, including the rightmost edge, allowing for non-uniform bin widths. range : (float, float), optional The lower and upper range of the bins. If not provided, range is simply ``(a.min(), a.max())``. Values outside the range are ignored. Note that with `new` set to False, values below the range are ignored, while those above the range are tallied in the rightmost bin. normed : bool, optional If False, the result will contain the number of samples in each bin. If True, the result is the value of the probability *density* function at the bin, normalized such that the *integral* over the range is 1. Note that the sum of the histogram values will often not be equal to 1; it is not a probability *mass* function. weights : array_like, optional An array of weights, of the same shape as `a`. Each value in `a` only contributes its associated weight towards the bin count (instead of 1). If `normed` is True, the weights are normalized, so that the integral of the density over the range remains 1. The `weights` keyword is only available with `new` set to True. new : {None, True, False}, optional Whether to use the new semantics for histogram: * None : the new behaviour is used, no warning is printed. * True : the new behaviour is used and a warning is raised about the future removal of the `new` keyword. * False : the old behaviour is used and a DeprecationWarning is raised. As of NumPy 1.3, this keyword should not be used explicitly since it will disappear in NumPy 1.4. Returns ------- hist : array The values of the histogram. See `normed` and `weights` for a description of the possible semantics. bin_edges : array of dtype float Return the bin edges ``(length(hist)+1)``. With ``new=False``, return the left bin edges (``length(hist)``). See Also -------- histogramdd Notes ----- All but the last (righthand-most) bin is half-open. In other words, if `bins` is:: [1, 2, 3, 4] then the first bin is ``[1, 2)`` (including 1, but excluding 2) and the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which *includes* 4. Examples -------- >>> np.histogram([1,2,1], bins=[0,1,2,3]) (array([0, 2, 1]), array([0, 1, 2, 3])) s The histogram semantics being used is now deprecated and will disappear in NumPy 1.4. Please update your code to use the default semantics. s/max must be larger than min in range parameter.gg?R`s*Use new=True to pass bin edges explicitly.is!bins must increase monotonically.s)weights are only available with new=True.iiig?s The new semantics of histogram is now the default and the `new` keyword will be removed in NumPy 1.4. s(weights should have the same shape as a.tlefttrighttdtypeN(#tFalsetwarningstwarntDeprecationWarningR4RNtNonetAttributeErrorRtmintmaxRt ValueErrortnpRtanyRQt searchsortedtxrangetsizeR2tlentTruetWarningtshapeRZRiR0R1tr_R3targsorttcumsumR[tsum(tatbinstrangetnormedtweightstnewtmntmxt_[1]tmitblocktntitdbt_[2]tntypetsatzerottmp_attmp_wt sorting_indextswtcwt bin_index((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRsI       +        (           +         #     cCsvy|i\}}Wn7ttfj o%t|i}|i\}}nXt|t}|dg}|dg} |dj ot|}ny*t |} | |jo tdnWn t j o||g}nX|djo@t t |i dt} t t |idt} nHt|} t|} x,t|D]} || \| | <| | } t"|t}|| d|| <|| | i|}qW||:}n|i|dji#ot$d n||fS( s Compute the multidimensional histogram of some data. Parameters ---------- sample : array_like Data to histogram passed as a sequence of D arrays of length N, or as an (N,D) array. bins : sequence or int, optional The bin specification: * A sequence of arrays describing the bin edges along each dimension. * The number of bins for each dimension (nx, ny, ... =bins) * The number of bins for all dimensions (nx=ny=...=bins). range : sequence, optional A sequence of lower and upper bin edges to be used if the edges are not given explicitely in `bins`. Defaults to the minimum and maximum values along each dimension. normed : boolean, optional If False, returns the number of samples in each bin. If True, returns the bin density, ie, the bin count divided by the bin hypervolume. weights : array_like (N,), optional An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`. Weights are normalized to 1 if normed is True. If normed is False, the values of the returned histogram are equal to the sum of the weights belonging to the samples falling into each bin. Returns ------- H : ndarray The multidimensional histogram of sample x. See normed and weights for the different possible semantics. edges : list A list of D arrays describing the bin edges for each dimension. See Also -------- histogram: 1D histogram histogram2d: 2D histogram Examples -------- >>> r = np.random.randn(100,3) >>> H, edges = np.histogramdd(r, bins = (5, 8, 4)) >>> H.shape, edges[0].size, edges[1].size, edges[2].size ((5,8,4), 6, 9, 5) sEThe dimension of bins must be equal to the dimension of the sample x.ig?iiNiisInternal Shape Error(%R{RoRrRVtTR6RZRnR4Rxt TypeErrorRUR3RpR[RqR0R1R@RRRRMR<R9tprodR}RtreshapeRQRwtswapaxestsliceRR/Rtt RuntimeError(tsampleRRRRtNtDtnbintedgestdedgestMtsmintsmaxRtNcounttoutlierstdecimalton_edgethisttniR{txyt flatcountRtjtcorets((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs3      "    *  + !- , !   cCst|tipti|}n|d jo/|i|}|ii|i|i}n|d}ti |d|idd}|i |i jo|d jo t dn|i djo t dn|i d|i |jo t dnti |ddd |i id |}n|id |}|djio td nti||i||}|o!ti|d|}||fS|Sd S(s Return the weighted average of array over the specified axis. Parameters ---------- a : array_like Data to be averaged. axis : int, optional Axis along which to average `a`. If `None`, averaging is done over the entire array irrespective of its shape. weights : array_like, optional The importance that each datum has in the computation of the average. The weights array can either be 1-D (in which case its length must be the size of `a` along the given axis) or of the same shape as `a`. If `weights=None`, then all data in `a` are assumed to have a weight equal to one. returned : bool, optional Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`) is returned, otherwise only the average is returned. Note that if `weights=None`, `sum_of_weights` is equivalent to the number of elements over which the average is taken. Returns ------- average, [sum_of_weights] : {array_type, double} Return the average along the specified axis. When returned is `True`, return a tuple with the average as the first element and the sum of the weights as the second element. The return type is `Float` if `a` is of integer type, otherwise it is of the same type as `a`. `sum_of_weights` is of the same type as `average`. Raises ------ ZeroDivisionError When all weights along axis are zero. See `numpy.ma.average` for a version robust to this type of error. TypeError When the length of 1D `weights` is not the same as the shape of `a` along axis. See Also -------- ma.average : average for masked arrays Examples -------- >>> data = range(1,5) >>> data [1, 2, 3, 4] >>> np.average(data) 2.5 >>> np.average(range(1,11), weights=range(10,0,-1)) 4.0 gRiRis;Axis must be specified when shapes of a and weights differ.is81D weights expected when shapes of a and weights differ.s5Length of weights not compatible with specified axis.tndminitaxiss(Weights sum to zero, can't be normalizedN(t isinstanceRstmatrixR4RnRRRittypeRwR3R{RtndimRrRRRttZeroDivisionErrorRB(RRRtreturnedtavgtscltwgt((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR(s.8       .  cCs`t|}|iitdjo9ti|ipti|io tdn|S(s7 Convert the input to an array, checking for NaNs or Infs. Parameters ---------- a : array_like Input data, in any form that can be converted to an array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists and ndarrays. Success requires no NaNs or Infs. dtype : data-type, optional By default, the data-type is inferred from the input data. order : {'C', 'F'}, optional Whether to use row-major ('C') or column-major ('FORTRAN') memory representation. Defaults to 'C'. Returns ------- out : ndarray Array interpretation of `a`. No copy is performed if the input is already an ndarray. If `a` is a subclass of ndarray, a base class ndarray is returned. Raises ------ ValueError Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). See Also -------- asarray : Create and array. asanyarray : Similar function which passes through subclasses. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major memory order. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid positions. Examples -------- Convert a list into an array. If all elements are finite ``asarray_chkfinite`` is identical to ``asarray``. >>> a = [1, 2] >>> np.asarray_chkfinite(a) array([1, 2]) Raises ValueError if array_like contains Nans or Infs. >>> a = [1, 2, np.inf] >>> try: ... np.asarray_chkfinite(a) ... except ValueError: ... print 'ValueError' ... ValueError tAllFloats#array must not contain infs or NaNs( R4RitcharRSR\RFRttisinfRr(R((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs < , c OsCt|}t|}t|p)t|dtpt|dt o |g}ng}|D]}|t|dtqf~}t|}||djoN|d} x%td|D]} | || O} qW|i | |d7}n||jo t dnt } |i djot|d}t} g} xQt|D]C} || i djo|| d} n || } | i | qFW| }nt|i|i}xyt|D]k} || }t|p|||| = 0``. >>> x = np.arange(6) - 2.5 # x runs from -2.5 to 2.5 in steps of 1 >>> np.piecewise(x, [x < 0, x >= 0.5], [-1,1]) array([-1., -1., -1., 1., 1., 1.]) Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for ``x >= 0``. >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x]) array([ 2.5, 1.5, 0.5, 0.5, 1.5, 2.5]) iRiis1function list and condition list must be the sameN(R5RxR@RtlistR8R4tboolRR-RrRjRRnRyR0R{RitcallableRwtsqueeze(txtcondlisttfunclisttargstkwtn2RtcRttotlisttktzerodt newcondlistt conditionRctitemtvals((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRsRL    -           "ic Cst|}t|}||jo tdn|g|}d}d}xhtd|dD]S}|||t||d7}||jo |dt||d9}q_q_Wt|tjptt|idjotd}x,t|dD]}|t||}qWt|tjo&|tt|it|}q||tt|i|i }nt |t |S(s Return an array drawn from elements in choicelist, depending on conditions. Parameters ---------- condlist : list of N boolean arrays of length M The conditions C_0 through C_(N-1) which determine from which vector the output elements are taken. choicelist : list of N arrays of length M Th vectors V_0 through V_(N-1), from which the output elements are chosen. Returns ------- output : 1-dimensional array of length M The output at position m is the m-th element of the first vector V_n for which C_n[m] is non-zero. Note that the output depends on the order of conditions, since the first satisfied condition is used. Notes ----- Equivalent to: :: output = [] for m in range(M): output += [V[m] for V,C in zip(values,cond) if C[m]] or [default] Examples -------- >>> t = np.arange(10) >>> s = np.arange(10)*100 >>> condlist = [t == 4, t > 5] >>> choicelist = [s, t] >>> np.select(condlist, choicelist) array([ 0, 0, 0, 0, 400, 0, 6, 7, 8, 9]) s7list of cases must be same length as list of conditionsii( RxRrRR4RR:RqR{R/RiRPttuple(Rt choicelisttdefaultRRtStpfacR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR>s*)       $/ &#cCst|dtS(s: Return an array copy of the given object. Parameters ---------- a : array_like Input data. Returns ------- arr : ndarray Array interpretation of `a`. Notes ----- This is equivalent to >>> np.array(a, copy=True) Examples -------- Create an array x, with a reference y and a copy z: >>> x = np.array([1, 2, 3]) >>> y = x >>> z = np.copy(x) Note that, when we modify x, y changes, but not z: >>> x[0] = 10 >>> x[0] == y[0] True >>> x[0] == z[0] False R(R3Ry(R((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR~s%c Gs0t|i}t|}|djodg|}nI|djo|dg|}n'||jot|}n tdg}td g|}td g|}td g|}|ii} | djo d} nx,t|D]} t |i|ii} tdd || >> np.gradient(np.array([[1,1],[3,4]])) [array([[ 2., 3.], [ 2., 3.]]), array([[ 0., 0.], [ 1., 1.]])] ig?isinvalid number of argumentstftdtFRiiig@N(RRRR( RxR{Rt SyntaxErrorRRnRiRRR0R-( RtvarargsRRtdxtoutvalstslice1tslice2tslice3totypeRtout((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRsL                  icCs|djo|S|djotdt|nt|}t|i}tdg|}tdg|}tdd||>> x = np.array([0,1,3,9,5,10]) >>> np.diff(x) array([ 1, 2, 6, -4, 5]) >>> np.diff(x,n=2) array([ 1, 4, -10, 9]) >>> x = np.array([[1,3,6,10],[0,5,6,8]]) >>> np.diff(x) array([[2, 3, 4], [5, 1, 2]]) >>> np.diff(x,axis=0) array([[-1, 2, 0, -2]]) is#order must be non-negative but got iiRN( RrtreprR5RxR{RRnRR(RRRtndRR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs"      $cCsSt|tttfo t|g||||iSt|||||SdS(s One-dimensional linear interpolation. Returns the one-dimensional piecewise linear interpolant to a function with given values at discrete data-points. Parameters ---------- x : array_like The x-coordinates of the interpolated values. xp : 1-D sequence of floats The x-coordinates of the data points, must be increasing. fp : 1-D sequence of floats The y-coordinates of the data points, same length as `xp`. left : float, optional Value to return for `x < xp[0]`, default is `fp[0]`. right : float, optional Value to return for `x > xp[-1]`, defaults is `fp[-1]`. Returns ------- y : {float, ndarray} The interpolated values, same shape as `x`. Raises ------ ValueError If `xp` and `fp` have different length Notes ----- Does not check that the x-coordinate sequence `xp` is increasing. If `xp` is not increasing, the results are nonsense. A simple check for increasingness is:: np.all(np.diff(xp) > 0) Examples -------- >>> xp = [1, 2, 3] >>> fp = [3, 2, 0] >>> np.interp(2.5, xp, fp) 1.0 >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) array([ 3. , 3. , 2.5, 0.56, 0. ]) >>> UNDEF = -99.0 >>> np.interp(3.14, xp, fp, right=UNDEF) -99.0 Plot an interpolant to the sine function: >>> x = np.linspace(0, 2*np.pi, 10) >>> y = np.sin(x) >>> xvals = np.linspace(0, 2*np.pi, 50) >>> yinterp = np.interp(xvals, x, y) >>> import matplotlib.pyplot as plt >>> plt.plot(x, y, 'o') >>> plt.plot(xvals, yinterp, '-x') >>> plt.show() N(RR[RZRTtcompiled_interpR(RtxptfpRgRh((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR.3sC cCss|odt}nd}t|}t|iitio|i}|i}n d}|}t |||S(s Return the angle of the complex argument. Parameters ---------- z : array_like A complex number or sequence of complex numbers. deg : bool, optional Return angle in degrees if True, radians if False (default). Returns ------- angle : {ndarray, scalar} The counterclockwise angle from the positive real axis on the complex plane, with dtype as numpy.float64. See Also -------- arctan2 Examples -------- >>> np.angle([1.0, 1.0j, 1+1j]) # in radians array([ 0. , 1.57079633, 0.78539816]) >>> np.angle(1+1j, deg=True) # in degrees 45.0 ig?i( RAR4t issubclassRiRR\tcomplexfloatingtimagtrealRD(tztdegtfacttzimagtzreal((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR |s   c Cst|}t|i}t|d|}tddg|}tdd||>> np.sort_complex([5, 3, 6, 2, 1]) array([ 1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j]) >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) array([ 1.+2.j, 2.-1.j, 3.-5.j, 3.-3.j, 3.+2.j]) RtbhBHRtgtGRN( R3RyRQRRiRR\RRtastype(Rtb((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR s tfbcCsd}|i}d|jo1x.|D]"}|djoPq&|d}q&Wnt|}d|jo>x;|dddD]"}|djoPq}|d}q}Wn|||!S(s3 Trim the leading and/or trailing zeros from a 1-D array or sequence. Parameters ---------- filt : 1-D array or sequence Input array. trim : str, optional A string with 'f' representing trim from front and 'b' to trim from back. Default is 'fb', trim zeros from both front and back of the array. Returns ------- trimmed : 1-D array or sequence The result of trimming the input. The input data type is preserved. Examples -------- >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0)) >>> np.trim_zeros(a) array([1, 2, 3, 0, 2, 1]) >>> np.trim_zeros(a, 'b') array([0, 0, 0, 1, 2, 3, 0, 2, 1]) The input data type is preserved, list/tuple in means list/tuple out. >>> np.trim_zeros([0, 1, 2, 0]) [1, 2] iRgitBNi(tupperRx(tfiltttrimtfirstRtlast((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs !      i(tSetc CsyZ|i}|idjo|S|ittg|d|d jf}||SWn6tj o*tt|}|it|SXdS(s Return the sorted, unique elements of an array or sequence. Parameters ---------- x : ndarray or sequence Input array. Returns ------- y : ndarray The sorted, unique elements are returned in a 1-D array. Examples -------- >>> np.unique([1, 1, 2, 2, 3, 3]) array([1, 2, 3]) >>> a = np.array([[1, 1], [2, 3]]) >>> np.unique(a) array([1, 2, 3]) >>> np.unique([True, True, False]) array([False, True], dtype=bool) iiiN( tflattenRwRQR2RyRoRtsetR4(Rttmptidxtitems((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR s  #  cCs&tit|tt|dS(s  Return the elements of an array that satisfy some condition. This is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``. Parameters ---------- condition : array_like An array whose nonzero or True entries indicate the elements of `arr` to extract. arr : array_like Input array of the same size as `condition`. See Also -------- take, put, putmask Examples -------- >>> arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]]) >>> arr array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) >>> condition = np.mod(arr, 3)==0 >>> condition array([[False, False, True, False], [False, True, False, False], [ True, False, False, True]], dtype=bool) >>> np.extract(condition, arr) array([ 3, 6, 9, 12]) If `condition` is boolean: >>> arr[condition] array([ 3, 6, 9, 12]) i(R\ttakeRNRO(Rtarr((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRDs(cCst|||S(sS Changes elements of an array based on conditional and input values. Similar to ``putmask(a, mask, vals)`` but the 1D array `vals` has the same number of elements as the non-zero values of `mask`. Inverse of ``extract``. Sets `a`.flat[n] = `values`\[n] for each n where `mask`.flat[n] is true. Parameters ---------- a : array_like Array to put data into. mask : array_like Boolean mask array. values : array_like, shape(number of non-zero `mask`, ) Values to put into `a`. See Also -------- putmask, put, take (RX(R tmaskR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRnscCsjt|dt}t|}|iotiSt|iiti p|||>> np.nansum(1) 1 >>> np.nansum([1]) 1 >>> np.nansum([1, np.nan]) 1.0 >>> a = np.array([[1, 1], [1, np.nan]]) >>> np.nansum(a) 3.0 >>> np.nansum(a, axis=0) array([ 2., 1.]) When positive infinity and negative infinity are present >>> np.nansum([1, np.nan, np.inf]) inf >>> np.nansum([1, np.nan, np.NINF]) -inf >>> np.nansum([1, np.nan, np.inf, np.NINF]) nan i(RRsR(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRsBcCsttiti||S(s Return the minimum of array elements over the given axis ignoring any NaNs. Parameters ---------- a : array_like Array containing numbers whose sum is desired. If `a` is not an array, a conversion is attempted. axis : int, optional Axis along which the minimum is computed.The default is to compute the minimum of the flattened array. Returns ------- y : {ndarray, scalar} An array with the same shape as `a`, with the specified axis removed. If `a` is a 0-d array, or if axis is None, a scalar is returned. The the same dtype as `a` is returned. See Also -------- numpy.amin : Minimum across array including any Not a Numbers. numpy.nanmax : Maximum across array ignoring any Not a Numbers. isnan : Shows which elements are Not a Number (NaN). isfinite: Shows which elements are not: Not a Number, positive and negative infinity Notes ----- Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number. If the input has a integer type, an integer type is returned unless the input contains NaNs and infinity. Examples -------- >>> a = np.array([[1, 2], [3, np.nan]]) >>> np.nanmin(a) 1.0 >>> np.nanmin(a, axis=0) array([ 1., 2.]) >>> np.nanmin(a, axis=1) array([ 1., 3.]) When positive infinity and negative infinity are present: >>> np.nanmin([1, 2, np.nan, np.inf]) 1.0 >>> np.nanmin([1, 2, np.nan, np.NINF]) -inf (RRsRptinf(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs:cCsttiti||S(s Return indices of the minimum values along an axis, ignoring NaNs. See Also -------- nanargmax : corresponding function for maxima; see for details. (RRstargminR(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR(s cCsttiti ||S(s Return the maximum of array elements over the given axis ignoring any NaNs. Parameters ---------- a : array_like Array containing numbers whose maximum is desired. If `a` is not an array, a conversion is attempted. axis : int, optional Axis along which the maximum is computed.The default is to compute the maximum of the flattened array. Returns ------- y : ndarray An array with the same shape as `a`, with the specified axis removed. If `a` is a 0-d array, or if axis is None, a scalar is returned. The the same dtype as `a` is returned. See Also -------- numpy.amax : Maximum across array including any Not a Numbers. numpy.nanmin : Minimum across array ignoring any Not a Numbers. isnan : Shows which elements are Not a Number (NaN). isfinite: Shows which elements are not: Not a Number, positive and negative infinity Notes ----- Numpy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number. If the input has a integer type, an integer type is returned unless the input contains NaNs and infinity. Examples -------- >>> a = np.array([[1, 2], [3, np.nan]]) >>> np.nanmax(a) 3.0 >>> np.nanmax(a, axis=0) array([ 3., 2.]) >>> np.nanmax(a, axis=1) array([ 2., 3.]) When positive infinity and negative infinity are present: >>> np.nanmax([1, 2, np.nan, np.NINF]) 2.0 >>> np.nanmax([1, 2, np.nan, np.inf]) inf (RRsRqR(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR4s8cCsttiti ||S(sr Return indices of the maximum values over an axis, ignoring NaNs. Parameters ---------- a : array_like Input data. axis : int, optional Axis along which to operate. By default flattened input is used. Returns ------- index_array : ndarray An array of indices or a single index value. See Also -------- argmax, nanargmin Examples -------- >>> a = np.array([[np.nan, 4], [2, 3]]) >>> np.argmax(a) 0 >>> np.nanargmax(a) 1 >>> np.nanargmax(a, axis=0) array([1, 1]) >>> np.nanargmax(a, axis=1) array([1, 0]) (RRstargmaxR(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRns!cCsa|djoddk}|i}n|o|id|n|id||idS(s{ Display a message on a device Parameters ---------- mesg : string Message to display. device : device object with 'write' method Device to write message. If None, defaults to ``sys.stdout`` which is very similar to ``print``. linefeed : bool, optional Option whether to print a line feed or not. Defaults to True. iNs%s s%s(Rntsyststdouttwritetflush(tmesgtdevicetlinefeedR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR s    cCsJt|p tdnt|dog|i}|i}|idj ot|i}nd}t|t i o|d8}n||fSt i d}y|d SWntj o{}|i t|}|oVt|id}t|id}t|t i o|d8}n||fSnXtd|dS( NsObject is not callable.t func_codeiisG.*? takes exactly (?P\d+) argument(s|) \((?P\d+) given\)texargstgargss2failed to determine the number of arguments for %s(ii(RRthasattrRt co_argcountt func_defaultsRnRxRttypest MethodTypetretcompiletmatchtstrRZtgroupRr(tobjtfcodetnargst ndefaultstterrtmsgtm((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyt _get_nargss0     cBs&eZdZdddZdZRS(s vectorize(pyfunc, otypes='', doc=None) Generalized function class. Define a vectorized function which takes a nested sequence of objects or numpy arrays as inputs and returns a numpy array as output. The vectorized function evaluates `pyfunc` over successive tuples of the input arrays like the python map function, except it uses the broadcasting rules of numpy. The data type of the output of `vectorized` is determined by calling the function with the first element of the input. This can be avoided by specifying the `otypes` argument. Parameters ---------- pyfunc : callable A python function or method. otypes : str or list of dtypes, optional The output data type. It must be specified as either a string of typecode characters or a list of data type specifiers. There should be one data type specifier for each output. doc : str, optional The docstring for the function. If None, the docstring will be the `pyfunc` one. Examples -------- >>> def myfunc(a, b): ... """Return a-b if a>b, otherwise return a+b""" ... if a > b: ... return a - b ... else: ... return a + b >>> vfunc = np.vectorize(myfunc) >>> vfunc([1, 2, 3, 4], 2) array([3, 4, 1, 2]) The docstring is taken from the input function to `vectorize` unless it is specified >>> vfunc.__doc__ 'Return a-b if a>b, otherwise return a+b' >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`') >>> vfunc.__doc__ 'Vectorized `myfunc`' The output type is determined by evaluating the first element of the input, unless it is specified >>> out = vfunc([1, 2, 3, 4], 2) >>> type(out[0]) >>> vfunc = np.vectorize(myfunc, otypes=[np.float]) >>> out = vfunc([1, 2, 3, 4], 2) >>> type(out[0]) tc CsH||_d|_t|\}}|djo#|djod|_d|_n||_|||_d|_|djo|i|_n ||_t|t o?||_ x|i D]$}|t djo t dqqWnTt |o=dig}|D]}|ti|iq~|_ n t dd|_dS(NitAllsinvalid otype specifiedR4sLoutput types must be a string of typecode characters or a list of data-types(tthefuncRntufuncR3tnintnin_wo_defaultstnoutt__doc__RR*totypesRSRrRtjoinR\RiRt lastcallargs( tselftpyfuncR<tdocR8tndefaultRRR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyt__init__s,            = c Gszt|}|io1||ijp||ijo tdqGn|i|jo||_d|_d|_n|idjp|idjog}x(|D] }|i t |i dqW|i |}t |tot||_nd|_|f}|idjoSg}x4t|iD]#}|i t ||iiq1Wdi||_qrn|idjot|i ||i|_ng}|D]%}|t|dtdtdtq~}|idjo2t|i|dtdtd|id} n[tg} t|i||iD]+\} } | t| dtdtd| q?~ } | S(Ns>mismatch between python function inputs and received argumentsR4iiRRRi(RxR8R9RrR>RnR7R:R<R-R4tflatR6RRRRiRR=RER3RjRytobjecttzip( R?RR.tnewargstargttheoutR<RRt_resRRR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyt__call__!sB         !9 PN(t__name__t __module__R;RnRCRK(((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs=c Csct|dddt}|iddjo d}n|od}td tf}nd}ttd f}|d j o7t|dtdddt}t||f|}n||idd||8}|o|id}n|id}|o|d}n |d}|p!t |i |i |i St ||i i |i Sd S( s Estimate a covariance matrix, given data. Covariance indicates the level to which two variables vary together. If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`, then the covariance matrix element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance of :math:`x_i`. Parameters ---------- m : array_like A 1-D or 2-D array containing multiple variables and observations. Each row of `m` represents a variable, and each column a single observation of all those variables. Also see `rowvar` below. y : array_like, optional An additional set of variables and observations. `y` has the same form as that of `m`. rowvar : int, optional If `rowvar` is non-zero (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations. bias : int, optional Default normalization is by ``(N-1)``, where ``N`` is the number of observations given (unbiased estimate). If `bias` is 1, then normalization is by ``N``. Returns ------- out : ndarray The covariance matrix of the variables. See Also -------- corrcoef : Normalized covariance matrix Examples -------- Consider two variables, :math:`x_0` and :math:`x_1`, which correlate perfectly, but in opposite directions: >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T >>> x array([[0, 1, 2], [2, 1, 0]]) Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance matrix shows this clearly: >>> np.cov(x) array([[ 1., -1.], [-1., 1.]]) Note that element :math:`C_{0,1}`, which shows the correlation between :math:`x_0` and :math:`x_1`, is negative. Further, note how `x` and `y` are combined: >>> x = [-2.1, -1, 4.3] >>> y = [3, 1.1, 0.12] >>> X = np.vstack((x,y)) >>> print np.cov(X) [[ 11.71 -4.286 ] [ -4.286 2.14413333]] >>> print np.cov(x, y) [[ 11.71 -4.286 ] [ -4.286 2.14413333]] >>> print np.cov(x) 11.71 RiRiiiRRg?N( R3R[R{RRnR=RjR2RRR;RtconjR( R2RctrowvartbiastXRttupRR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRNs*J    !cCsVt||||}yt|}Wntj odSX|tti||S(s~ Return correlation coefficients. Please refer to the documentation for `cov` for more detail. The relationship between the correlation coefficient matrix, P, and the covariance matrix, C, is .. math:: P_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} * C_{jj} } } The values of P are between -1 and 1. See Also -------- cov : Covariance matrix i(RRWRrRIRBtouter(RRcRORPRR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRs cCs|djo tgS|djotdtStd|}ddtdt||ddtdt||dS(s Return the Blackman window. The Blackman window is a taper formed by using the the first three terms of a summation of cosines. It was designed to have close to the minimal leakage possible. It is close to optimal, only slightly worse than a Kaiser window. Parameters ---------- M : int Number of points in the output window. If zero or less, an empty array is returned. Returns ------- out : array The window, normalized to one (the value one appears only if the number of samples is odd). See Also -------- bartlett, hamming, hanning, kaiser Notes ----- The Blackman window is defined as .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) Most references to the Blackman window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. It is known as a "near optimal" tapering function, almost as good (by some measures) as the kaiser window. References ---------- .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, Dover Publications, New York. .. [2] Wikipedia, "Window function", http://en.wikipedia.org/wiki/Window_function .. [3] Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. Examples -------- >>> from numpy import blackman >>> blackman(12) array([ -1.38777878e-17, 3.26064346e-02, 1.59903635e-01, 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) Plot the window and the frequency response: >>> from numpy import clip, log10, array, bartlett >>> from scipy.fftpack import fft, fftshift >>> import matplotlib.pyplot as plt >>> window = blackman(51) >>> plt.plot(window) >>> plt.title("Blackman window") >>> plt.ylabel("Amplitude") >>> plt.xlabel("Sample") >>> plt.show() >>> A = fft(window, 2048) / 25.5 >>> mag = abs(fftshift(A)) >>> freq = linspace(-0.5,0.5,len(A)) >>> response = 20*log10(mag) >>> response = clip(response,-100,100) >>> plt.plot(freq, response) >>> plt.title("Frequency response of Bartlett window") >>> plt.ylabel("Magnitude [dB]") >>> plt.xlabel("Normalized frequency [cycles per sample]") >>> plt.axis('tight'); plt.show() iigzG?g?g@g{Gz?g@(R3R/R[R1RGRA(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR$s T   cCs|djo tgS|djotdtStd|}tt||ddd||ddd||dS(s: Return the Bartlett window. The Bartlett window is very similar to a triangular window, except that the end points are at zero. It is often used in signal processing for tapering a signal, without generating too much ripple in the frequency domain. Parameters ---------- M : int Number of points in the output window. If zero or less, an empty array is returned. Returns ------- out : array The triangular window, normalized to one (the value one appears only if the number of samples is odd), with the first and last samples equal to zero. See Also -------- blackman, hamming, hanning, kaiser Notes ----- The Bartlett window is defined as .. math:: w(n) = \frac{2}{M-1} \left( \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| \right) Most references to the Bartlett window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. Note that convolution with this window produces linear interpolation. It is also known as an apodization (which means"removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. The fourier transform of the Bartlett is the product of two sinc functions. Note the excellent discussion in Kanasewich. References ---------- .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", Biometrika 37, 1-16, 1950. .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The University of Alberta Press, 1975, pp. 109-110. .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal Processing", Prentice-Hall, 1999, pp. 468-471. .. [4] Wikipedia, "Window function", http://en.wikipedia.org/wiki/Window_function .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, "Numerical Recipes", Cambridge University Press, 1986, page 429. Examples -------- >>> np.bartlett(12) array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, 0.18181818, 0. ]) Plot the window and its frequency response (requires SciPy and matplotlib): >>> from numpy import clip, log10, array, bartlett >>> from numpy.fft import fft >>> import matplotlib.pyplot as plt >>> window = bartlett(51) >>> plt.plot(window) >>> plt.title("Bartlett window") >>> plt.ylabel("Amplitude") >>> plt.xlabel("Sample") >>> plt.show() >>> A = fft(window, 2048) / 25.5 >>> mag = abs(fftshift(A)) >>> freq = linspace(-0.5,0.5,len(A)) >>> response = 20*log10(mag) >>> response = clip(response,-100,100) >>> plt.plot(freq, response) >>> plt.title("Frequency response of Bartlett window") >>> plt.ylabel("Magnitude [dB]") >>> plt.xlabel("Normalized frequency [cycles per sample]") >>> plt.axis('tight'); plt.show() iig@(R3R/R[R1R<RH(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR#*s Z   cCsd|djo tgS|djotdtStd|}ddtdt||dS(s Return the Hanning window. The Hanning window is a taper formed by using a weighted cosine. Parameters ---------- M : int Number of points in the output window. If zero or less, an empty array is returned. Returns ------- out : ndarray, shape(M,) The window, normalized to one (the value one appears only if `M` is odd). See Also -------- bartlett, blackman, hamming, kaiser Notes ----- The Hanning window is defined as .. math:: w(n) = 0.5 - 0.5cos\left(\frac{2\pi{n}}{M-1}\right) \qquad 0 \leq n \leq M-1 The Hanning was named for Julius van Hann, an Austrian meterologist. It is also known as the Cosine Bell. Some authors prefer that it be called a Hann window, to help avoid confusion with the very similar Hamming window. Most references to the Hanning window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. References ---------- .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, Dover Publications, New York. .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The University of Alberta Press, 1975, pp. 106-108. .. [3] Wikipedia, "Window function", http://en.wikipedia.org/wiki/Window_function .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, "Numerical Recipes", Cambridge University Press, 1986, page 425. Examples -------- >>> from numpy import hanning >>> hanning(12) array([ 0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, 0.07937323, 0. ]) Plot the window and its frequency response: >>> from numpy.fft import fft, fftshift >>> import matplotlib.pyplot as plt >>> window = np.hanning(51) >>> plt.subplot(121) >>> plt.plot(window) >>> plt.title("Hann window") >>> plt.ylabel("Amplitude") >>> plt.xlabel("Sample") >>> A = fft(window, 2048) / 25.5 >>> mag = abs(fftshift(A)) >>> freq = np.linspace(-0.5,0.5,len(A)) >>> response = 20*np.log10(mag) >>> response = np.clip(response,-100,100) >>> plt.subplot(122) >>> plt.plot(freq, response) >>> plt.title("Frequency response of the Hann window") >>> plt.ylabel("Magnitude [dB]") >>> plt.xlabel("Normalized frequency [cycles per sample]") >>> plt.axis('tight'); plt.show() iig?g@(R3R/R[R1RGRA(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR"s S   cCsd|djo tgS|djotdtStd|}ddtdt||dS(s Return the Hamming window. The Hamming window is a taper formed by using a weighted cosine. Parameters ---------- M : int Number of points in the output window. If zero or less, an empty array is returned. Returns ------- out : ndarray The window, normalized to one (the value one appears only if the number of samples is odd). See Also -------- bartlett, blackman, hanning, kaiser Notes ----- The Hamming window is defined as .. math:: w(n) = 0.54 + 0.46cos\left(\frac{2\pi{n}}{M-1}\right) \qquad 0 \leq n \leq M-1 The Hamming was named for R. W. Hamming, an associate of J. W. Tukey and is described in Blackman and Tukey. It was recommended for smoothing the truncated autocovariance function in the time domain. Most references to the Hamming window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. References ---------- .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, Dover Publications, New York. .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The University of Alberta Press, 1975, pp. 109-110. .. [3] Wikipedia, "Window function", http://en.wikipedia.org/wiki/Window_function .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, "Numerical Recipes", Cambridge University Press, 1986, page 425. Examples -------- >>> from numpy import hamming >>> hamming(12) array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, 0.15302337, 0.08 ]) Plot the window and the frequency response: >>> from numpy import clip, log10, array, hamming >>> from scipy.fftpack import fft, fftshift >>> import matplotlib.pyplot as plt >>> window = hamming(51) >>> plt.plot(window) >>> plt.title("Hamming window") >>> plt.ylabel("Amplitude") >>> plt.xlabel("Sample") >>> plt.show() >>> A = fft(window, 2048) / 25.5 >>> mag = abs(fftshift(A)) >>> freq = linspace(-0.5,0.5,len(A)) >>> response = 20*log10(mag) >>> response = clip(response,-100,100) >>> plt.plot(freq, response) >>> plt.title("Frequency response of Hamming window") >>> plt.ylabel("Magnitude [dB]") >>> plt.xlabel("Normalized frequency [cycles per sample]") >>> plt.axis('tight'); plt.show() iigHzG?gq= ףp?g@(R3R/R[R1RGRA(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR!s R   g4!\Tg}b3g0 Kg5dMv;p>g"c쑾g$>g'doҾgY(X?>gZY&+g|t(?gRBguZ?gI ^qga?g!Ng-Ί>?g-4pKgw?gWӿg*5N?gT`g0fFVg!g["d,->gmրVX>gna>g+A>gRx?gI墌k?g b?cCs^|d}d}x?tdt|D](}|}|}|||||}q&Wd||S(Nigig?(RvRx(RRtb0tb1Rtb2((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyt_chbevl{ s cCst|t|ddtS(Ng@i(RLRWt_i0A(R((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyt_i0_1 scCs)t|td|dtt|S(Ng@@g@(RLRWt_i0BRI(R((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyt_i0_2 scCs~t|i}t|}|dj}|| ||<|dj}t||||<|}t||||<|iS(s\ Modified Bessel function of the first kind, order 0. Usually denoted :math:`I_0`. Parameters ---------- x : array_like, dtype float or complex Argument of the Bessel function. Returns ------- out : ndarray, shape z.shape, dtype z.dtype The modified Bessel function evaluated at the elements of `x`. See Also -------- scipy.special.iv, scipy.special.ive References ---------- .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", 10th printing, 1964, pp. 374. http://www.math.sfu.ca/~cbm/aands/ .. [2] Wikipedia, "Bessel function", http://en.wikipedia.org/wiki/Bessel_function Examples -------- >>> np.i0([0.]) array(1.0) >>> np.i0([0., 1. + 2j]) array([ 1.00000000+0.j , 0.18785373+0.64616944j]) ig @(RURR7RYR[R(RRctindtind2((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR' s#   cCsaddkl}td|}|dd}||td|||d|t|S(sk Return the Kaiser window. The Kaiser window is a taper formed by using a Bessel function. Parameters ---------- M : int Number of points in the output window. If zero or less, an empty array is returned. beta : float Shape parameter for window. Returns ------- out : array The window, normalized to one (the value one appears only if the number of samples is odd). See Also -------- bartlett, blackman, hamming, hanning Notes ----- The Kaiser window is defined as .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} \right)/I_0(\beta) with .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, where :math:`I_0` is the modified zeroth-order Bessel function. The Kaiser was named for Jim Kaiser, who discovered a simple approximation to the DPSS window based on Bessel functions. The Kaiser window is a very good approximation to the Digital Prolate Spheroidal Sequence, or Slepian window, which is the transform which maximizes the energy in the main lobe of the window relative to total energy. The Kaiser can approximate many other windows by varying the beta parameter. ==== ======================= beta Window shape ==== ======================= 0 Rectangular 5 Similar to a Hamming 6 Similar to a Hanning 8.6 Similar to a Blackman ==== ======================= A beta value of 14 is probably a good starting point. Note that as beta gets large, the window narrows, and so the number of samples needs to be large enough to sample the increasingly narrow spike, otherwise nans will get returned. Most references to the Kaiser window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. References ---------- .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. John Wiley and Sons, New York, (1966). .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The University of Alberta Press, 1975, pp. 177-178. .. [3] Wikipedia, "Window function", http://en.wikipedia.org/wiki/Window_function Examples -------- >>> from numpy import kaiser >>> kaiser(12, 14) array([ 7.72686684e-06, 3.46009194e-03, 4.65200189e-02, 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) Plot the window and the frequency response: >>> from numpy import clip, log10, array, kaiser >>> from scipy.fftpack import fft, fftshift >>> import matplotlib.pyplot as plt >>> window = kaiser(51, 14) >>> plt.plot(window) >>> plt.title("Kaiser window") >>> plt.ylabel("Amplitude") >>> plt.xlabel("Sample") >>> plt.show() >>> A = fft(window, 2048) / 25.5 >>> mag = abs(fftshift(A)) >>> freq = linspace(-0.5,0.5,len(A)) >>> response = 20*log10(mag) >>> response = clip(response,-100,100) >>> plt.plot(freq, response) >>> plt.title("Frequency response of Kaiser window") >>> plt.ylabel("Magnitude [dB]") >>> plt.xlabel("Normalized frequency [cycles per sample]") >>> plt.axis('tight'); plt.show() i(R'iig@(t numpy.dualR'R1RIR[(RtbetaR'Rtalpha((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR% sqcCs*tt|djd|}t||S(s$ Return the sinc function. The sinc function is :math:`\sin(\pi x)/(\pi x)`. Parameters ---------- x : ndarray Array (possibly multi-dimensional) of values for which to to calculate ``sinc(x)``. Returns ------- out : ndarray ``sinc(x)``, which has the same shape as the input. Notes ----- ``sinc(0)`` is the limit value 1. The name sinc is short for "sine cardinal" or "sinus cardinalis". The sinc function is used in various signal processing applications, including in anti-aliasing, in the construction of a Lanczos resampling filter, and in interpolation. For bandlimited interpolation of discrete-time signals, the ideal interpolation kernel is proportional to the sinc function. References ---------- .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/SincFunction.html .. [2] Wikipedia, "Sinc function", http://en.wikipedia.org/wiki/Sinc_function Examples -------- >>> x = np.arange(-20., 21.)/5. >>> np.sinc(x) array([ -3.89804309e-17, -4.92362781e-02, -8.40918587e-02, -8.90384387e-02, -5.84680802e-02, 3.89804309e-17, 6.68206631e-02, 1.16434881e-01, 1.26137788e-01, 8.50444803e-02, -3.89804309e-17, -1.03943254e-01, -1.89206682e-01, -2.16236208e-01, -1.55914881e-01, 3.89804309e-17, 2.33872321e-01, 5.04551152e-01, 7.56826729e-01, 9.35489284e-01, 1.00000000e+00, 9.35489284e-01, 7.56826729e-01, 5.04551152e-01, 2.33872321e-01, 3.89804309e-17, -1.55914881e-01, -2.16236208e-01, -1.89206682e-01, -1.03943254e-01, -3.89804309e-17, 8.50444803e-02, 1.26137788e-01, 1.16434881e-01, 6.68206631e-02, 3.89804309e-17, -5.84680802e-02, -8.90384387e-02, -8.40918587e-02, -4.92362781e-02, -3.89804309e-17]) >>> import matplotlib.pyplot as plt >>> plt.plot(x, sinc(x)) >>> plt.title("Sinc Function") >>> plt.ylabel("Amplitude") >>> plt.xlabel("X") >>> plt.show() It works in 2-D as well: >>> x = np.arange(-200., 201.)/50. >>> xx = np.outer(x, x) >>> plt.imshow(sinc(xx)) ig#B ;(RAR<RJ(RRc((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR 1 sFcCs)t|dtdt}|id|S(sk Return a copy of an array sorted along the first axis. Parameters ---------- a : array_like Array to be sorted. Returns ------- sorted_array : ndarray Array of the same type and shape as `a`. See Also -------- sort Notes ----- ``np.msort(a)`` is equivalent to ``np.sort(a, axis=0)``. RRi(R3RyRQ(RR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyRz s cCs|oA|djo|i}|iqZ|id||}nt|d|}|djo d}ntdg|i}t|i|d}|i|ddjot||d||>> a = np.array([[10, 7, 4], [3, 2, 1]]) >>> a array([[10, 7, 4], [ 3, 2, 1]]) >>> np.median(a) 3.5 >>> np.median(a, axis=0) array([ 6.5, 4.5, 2.5]) >>> np.median(a, axis=1) array([ 7., 2.]) >>> m = np.median(a, axis=0) >>> out = np.zeros_like(m) >>> np.median(a, axis=0, out=m) array([ 6.5, 4.5, 2.5]) >>> m array([ 6.5, 4.5, 2.5]) >>> b = a.copy() >>> np.median(b, axis=1, overwrite_input=True) array([ 7., 2.]) >>> assert not np.all(a==b) >>> b = a.copy() >>> np.median(b, axis=None, overwrite_input=True) 3.5 >>> assert not np.all(a==b) RiiiRN(RnRNRQRRRZR{RR(RRRtoverwrite_inputtsortedtindexertindex((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR sJ     g?c Cst|}|djo |}not|}|idjo@t|}dg|i}|id||<|i|}nt|d|}t|i}tdg|}tdg|}tdd||>> np.trapz([1,2,3]) >>> 4.0 >>> np.trapz([1,2,3], [4,6,8]) >>> 8.0 iiRig@N( R4RnRRR{RRxRRCtreduce( RcRRRRR{RRR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR& s      c Bsyh}d||f|Ue|eoe|||ine|eo,ee|||d|dinNe|eo=x:|D].}ee|||d|diqWnWnnXdS(sAdds documentation to obj which is in module place. If doc is a string add it to obj as a docstring If doc is a tuple, then the first element is interpreted as an attribute of obj and the second as the docstring (method, docstring) If doc is a list, then each element of the list should be a sequence of length two --> [(method1, docstring1), (method2, docstring2), ...] This routine never raises an error. sfrom %s import %siiN(RR*R)tstripRtgetattrR(RR,RARtval((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR(# s,4cCst|}t|}t|t|}}|id|}|i|dd}|i|d}|i|dd}||fS(s Return coordinate matrices from two coordinate vectors. Parameters ---------- x, y : ndarray Two 1-D arrays representing the x and y coordinates of a grid. Returns ------- X, Y : ndarray For vectors `x`, `y` with lengths ``Nx=len(x)`` and ``Ny=len(y)``, return `X`, `Y` where `X` and `Y` are ``(Ny, Nx)`` shaped arrays with the elements of `x` and y repeated to fill the matrix along the first dimension for `x`, the second for `y`. See Also -------- index_tricks.mgrid : Construct a multi-dimensional "meshgrid" using indexing notation. index_tricks.ogrid : Construct an open multi-dimensional "meshgrid" using indexing notation. Examples -------- >>> X, Y = np.meshgrid([1,2,3], [4,5,6,7]) >>> X array([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]) >>> Y array([[4, 4, 4], [5, 5, 5], [6, 6, 6], [7, 7, 7]]) `meshgrid` is very useful to evaluate functions on a grid. >>> x = np.arange(-5, 5, 0.1) >>> y = np.arange(-5, 5, 0.1) >>> xx, yy = np.meshgrid(x, y) >>> z = np.sin(xx**2+yy**2)/(xx**2+yy**2) iRi(R4RxRtrepeat(RRctnumRowstnumColsRQtY((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR*A s.  c Csd}t|tj o'y |i}Wq@tj oq@Xnt|}|i}|djo4|djo|i}n|i}|d}n|djo |o ||S|iSnt dg|}|i |}t |i }t |t ttfo|djo||7}n|djp ||jo tdn||cd8>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) >>> arr array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) >>> np.delete(arr, 1, 0) array([[ 1, 2, 3, 4], [ 9, 10, 11, 12]]) >>> np.delete(arr, np.s_[::2], 1) array([[ 2, 4], [ 6, 8], [10, 12]]) >>> np.delete(arr, [1,3,5], None) array([ 1, 3, 5, 7, 8, 9, 10, 11, 12]) iis invalid entryRiRRN(RnRR8t__array_wrap__RoR4RRNRRR{RRRZtlongR?RrR6RitflagstfnctindicesRxRvR1R>RYR3(R R,RtwrapRtslobjRtnewshapeRtslobj2R]R^RbtnumtodelR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR+y s-                     cCs"d}t|tj o'y |i}Wq@tj oq@Xnt|}|i}|djo4|djo|i}n|i}|d}n|djo0|i}||d<|o ||S|Snt dg|}|i |}t |i }t |t ttfo|djo||7}n|djp ||jotd|||fn||cd7>> a = np.array([[1, 1], [2, 2], [3, 3]]) >>> a array([[1, 1], [2, 2], [3, 3]]) >>> np.insert(a, 1, 5) array([1, 5, 1, 2, 2, 3, 3]) >>> np.insert(a, 1, 5, axis=1) array([[1, 5, 1], [2, 5, 2], [3, 5, 3]]) >>> b = a.flatten() >>> b array([1, 1, 2, 2, 3, 3]) >>> np.insert(b, [2, 2], [5, 6]) array([1, 1, 5, 6, 2, 2, 3, 3]) >>> np.insert(b, slice(2, 4), [5, 6]) array([1, 1, 5, 2, 6, 2, 3, 3]) >>> np.insert(b, [2, 2], [7.13, False]) array([1, 1, 7, 0, 2, 2, 3, 3]) ii.s6index (%d) out of range (0<=index<=%d) in dimension %dRiN(RnRR8RmRoR4RRNRRR{RRRZRnR?RrR6RiRoRpR1RqR>RxRY(R R,tvaluesRRrRRsRRtRRutnumnewtindex1tindex2((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR, sr8                #      cCslt|}|djo=|idjo|i}nt|}|id}nt||fd|S(s Append values to the end of an array. Parameters ---------- arr : array_like Values are appended to a copy of this array. values : array_like These values are appended to a copy of `arr`. It must be of the correct shape (the same shape as `arr`, excluding `axis`). If `axis` is not specified, `values` can be any shape and will be flattened before use. axis : int, optional The axis along which `values` are appended. If `axis` is not given, both `arr` and `values` are flattened before use. Returns ------- out : ndarray A copy of `arr` with `values` appended to `axis`. Note that `append` does not occur in-place: a new array is allocated and filled. If `axis` is None, `out` is a flattened array. See Also -------- insert : Insert elements into an array. delete : Delete elements from an array. Examples -------- >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]]) array([1, 2, 3, 4, 5, 6, 7, 8, 9]) When `axis` is specified, `values` must have the correct shape. >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0) array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) iRN(R5RnRRNR2(R RwR((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyR-r s*   (}t __docformat__t__all__RkR%tnumpy.core.numericRtnumericR\R/R0R1R2R3R4R5R6R7R8R9R:R;R<R=R>R?R@tnumpy.core.umathRARBRCRDRERFRGRHRIRJRKRLRMtnumpy.core.fromnumericRNRORPRQRRtnumpy.core.numerictypesRSRTtnumpy.lib.shape_baseRURVtnumpy.lib.twodim_baseRWt_compiled_baseRXR)RRR.Rt arraysetopsRYtnumpyRsRyRjRRRRnRRRRRRRRRR R R RRt hexversiontsetsRRR RRRRRRRRR R'R3RERRRR$R#R"R!RXRZRWRYR[R'R%R RRR&R(R*R+R,R-(((sGC:\graphics\Tools\Python26\Lib\site-packages\numpy\lib\function_base.pyts     L4X( RH Z B z @ ) Y3I *# # .  & *  D < : #  i [ a Z \     / v I `.  8 ~ {