&]\c@`s!dZddlmZmZmZddlZddlmZddlZddlm Z ddl Z ddl m Z e e jdkre jjZn dZe e jd krdd l mZnd Zd Zed Ze e jdkr dZn dZe e jdkr;ddl mZneeedZe e jdkrte jjjZn edZyddlmZWn'ek rdefdYZnXe e jd krddl mZn7ddl m Z m!Z!m"Z"e#eee#e#e#dZdS(s4Functions copypasted from newer versions of numpy. i(tdivisiontprint_functiontabsolute_importN(tWarningMessage(twraps(t NumpyVersions 1.7.0.devc O`stjdt}tjd|||}t|dksYtd|jn|dj|k rtd|j||dfnWdQX|S(s^ Fail unless the given callable throws the specified warning. This definition is copypasted from numpy 1.9.0.dev. The version in earlier numpy returns None. Parameters ---------- warning_class : class The class defining the warning that `func` is expected to throw. func : callable The callable to test. *args : Arguments Arguments passed to `func`. **kwargs : Kwargs Keyword arguments passed to `func`. Returns ------- The value returned by `func`. trecordtalwaysis!No warning raised when calling %ss(First warning for %s is not a %s( is %s)N(twarningstcatch_warningstTruet simplefiltertlentAssertionErrort__name__tcategory(t warning_classtfunctargstkwtltresult((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt _assert_warnss #s1.10.0(t broadcast_tocC`sPt|t|k rL|jdt|}|jrL|j|qLn|S(Nttype(Rtviewt__array_finalize__(toriginal_arrayt new_array((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt_maybe_view_as_subclass:s  c C`stj|rt|n|f}tj|dtd|}| r^|jr^tdntd|Drtdntj|fdddd gd d gd |d dj d}t ||}| r|j j rt |j _ n|S(Ntcopytsuboks/cannot broadcast a non-scalar to a scalar arraycs`s|]}|dkVqdS(iN((t.0tsize((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pys Kss4all elements of broadcast shape must be non-negativetflagst multi_indextrefs_okt zerosize_oktop_flagstreadonlyt itershapetordertCi(tnptiterablettupletarraytFalsetshapet ValueErrortanytnditertitviewsRR"t writeableR (R.R0RR't broadcastR((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt _broadcast_toFs$cC`st||d|dtS(NRR'(R7R (R.R0R((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyRVss1.11.0cC`s|jS(N(trandint(t random_state((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt get_randint[sc`stjfd}|S(Nc`st|tj|jtjtjj}t|tj|jtjtjj}j|d|d|}|j|dtS(NthighR!R(tmaxR+tiinfotmintint32R8tastypeR/(tlowR;R!tdtypetintegers(R9(s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pytrandint_patchedas--(R+R?(R9RD((R9s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyR:`ss1.9.0(tuniquec C`stj|j}|p|}|p*|}|jdkr|sK|}nx|f}|ry|tjdtjf7}n|r|tjdtjf7}n|r|tjdtjf7}n|S|r|jd|rdnd}||}n|j|}tj t g|d|d kf} |sA|| }n|| f}|rh||| f7}n|rtj | d} tj|j dtj} | | |<|| f7}n|rtj tj | |jgf} |tj| f7}n|S(sP Find the unique elements of an array. Returns the sorted unique elements of an array. There are three optional outputs in addition to the unique elements: the indices of the input array that give the unique values, the indices of the unique array that reconstruct the input array, and the number of times each unique value comes up in the input array. Parameters ---------- ar : array_like Input array. This will be flattened if it is not already 1-D. return_index : bool, optional If True, also return the indices of `ar` that result in the unique array. return_inverse : bool, optional If True, also return the indices of the unique array that can be used to reconstruct `ar`. return_counts : bool, optional If True, also return the number of times each unique value comes up in `ar`. .. versionadded:: 1.9.0 Returns ------- unique : ndarray The sorted unique values. unique_indices : ndarray, optional The indices of the first occurrences of the unique values in the (flattened) original array. Only provided if `return_index` is True. unique_inverse : ndarray, optional The indices to reconstruct the (flattened) original array from the unique array. Only provided if `return_inverse` is True. unique_counts : ndarray, optional The number of times each of the unique values comes up in the original array. Only provided if `return_counts` is True. .. versionadded:: 1.9.0 Notes ----- Taken over from numpy 1.12.0-dev (c8408bf9c). Omitted examples, see numpy documentation for those. itkindt mergesortt quicksortiiRB(R+t asanyarraytflattenR!temptytbooltintptargsorttsortt concatenateR tcumsumR0tnonzerotdiff( tart return_indextreturn_inverset return_countstoptional_indicestoptional_returnstrettpermtauxtflagtiflagtinv_idxtidx((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyREmsD0      &   %s 1.12.0.devcC`stj|dddd}|jjdkrB|jtj}nt|ttfritj |}nt|tj r|r|j |j d|j }q|j |j krtdqntj||ddS( s Evaluate a polynomial specified by its roots at points x. This function is copypasted from numpy 1.12.0.dev. If `r` is of length `N`, this function returns the value .. math:: p(x) = \prod_{n=1}^{N} (x - r_n) The parameter `x` is converted to an array only if it is a tuple or a list, otherwise it is treated as a scalar. In either case, either `x` or its elements must support multiplication and addition both with themselves and with the elements of `r`. If `r` is a 1-D array, then `p(x)` will have the same shape as `x`. If `r` is multidimensional, then the shape of the result depends on the value of `tensor`. If `tensor is ``True`` the shape will be r.shape[1:] + x.shape; that is, each polynomial is evaluated at every value of `x`. If `tensor` is ``False``, the shape will be r.shape[1:]; that is, each polynomial is evaluated only for the corresponding broadcast value of `x`. Note that scalars have shape (,). Parameters ---------- x : array_like, compatible object If `x` is a list or tuple, it is converted to an ndarray, otherwise it is left unchanged and treated as a scalar. In either case, `x` or its elements must support addition and multiplication with with themselves and with the elements of `r`. r : array_like Array of roots. If `r` is multidimensional the first index is the root index, while the remaining indices enumerate multiple polynomials. For instance, in the two dimensional case the roots of each polynomial may be thought of as stored in the columns of `r`. tensor : boolean, optional If True, the shape of the roots array is extended with ones on the right, one for each dimension of `x`. Scalars have dimension 0 for this action. The result is that every column of coefficients in `r` is evaluated for every element of `x`. If False, `x` is broadcast over the columns of `r` for the evaluation. This keyword is useful when `r` is multidimensional. The default value is True. Returns ------- values : ndarray, compatible object The shape of the returned array is described above. See Also -------- polyroots, polyfromroots, polyval Examples -------- >>> from numpy.polynomial.polynomial import polyvalfromroots >>> polyvalfromroots(1, [1,2,3]) 0.0 >>> a = np.arange(4).reshape(2,2) >>> a array([[0, 1], [2, 3]]) >>> polyvalfromroots(a, [-1, 0, 1]) array([[ -0., 0.], [ 6., 24.]]) >>> r = np.arange(-2, 2).reshape(2,2) # multidimensional coefficients >>> r # each column of r defines one polynomial array([[-2, -1], [ 0, 1]]) >>> b = [-2, 1] >>> polyvalfromroots(b, r, tensor=True) array([[-0., 3.], [ 3., 0.]]) >>> polyvalfromroots(b, r, tensor=False) array([-0., 0.]) tndminiRis ?bBhHiIlLqQpPs,x.ndim must be < r.ndim when tensor == Falsetaxis(i(R+R.RBtcharR@tdoublet isinstanceR-tlisttasarraytndarraytreshapeR0tndimR1tprod(txtrttensor((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pytpolyvalfromrootssK (tsuppress_warningsRpcB`seZdZddZdZedd edZedd dZ edd dZ dZ d Z d Z d ZRS( s Context manager and decorator doing much the same as ``warnings.catch_warnings``. However, it also provides a filter mechanism to work around https://bugs.python.org/issue4180. This bug causes Python before 3.4 to not reliably show warnings again after they have been ignored once (even within catch_warnings). It means that no "ignore" filter can be used easily, since following tests might need to see the warning. Additionally it allows easier specificity for testing warnings and can be nested. Parameters ---------- forwarding_rule : str, optional One of "always", "once", "module", or "location". Analogous to the usual warnings module filter mode, it is useful to reduce noise mostly on the outmost level. Unsuppressed and unrecorded warnings will be forwarded based on this rule. Defaults to "always". "location" is equivalent to the warnings "default", match by exact location the warning warning originated from. Notes ----- Filters added inside the context manager will be discarded again when leaving it. Upon entering all filters defined outside a context will be applied automatically. When a recording filter is added, matching warnings are stored in the ``log`` attribute as well as in the list returned by ``record``. If filters are added and the ``module`` keyword is given, the warning registry of this module will additionally be cleared when applying it, entering the context, or exiting it. This could cause warnings to appear a second time after leaving the context if they were configured to be printed once (default) and were already printed before the context was entered. Nesting this context manager will work as expected when the forwarding rule is "always" (default). Unfiltered and unrecorded warnings will be passed out and be matched by the outer level. On the outmost level they will be printed (or caught by another warnings context). The forwarding rule argument can modify this behaviour. Like ``catch_warnings`` this context manager is not threadsafe. Examples -------- >>> with suppress_warnings() as sup: ... sup.filter(DeprecationWarning, "Some text") ... sup.filter(module=np.ma.core) ... log = sup.record(FutureWarning, "Does this occur?") ... command_giving_warnings() ... # The FutureWarning was given once, the filtered warnings were ... # ignored. All other warnings abide outside settings (may be ... # printed/error) ... assert_(len(log) == 1) ... assert_(len(sup.log) == 1) # also stored in log attribute Or as a decorator: >>> sup = suppress_warnings() >>> sup.filter(module=np.ma.core) # module must match exact >>> @sup >>> def some_function(): ... # do something which causes a warning in np.ma.core ... pass RcC`sFt|_g|_|ddddhkr9tdn||_dS(NRtmoduletoncetlocationsunsupported forwarding rule.(R/t_enteredt _suppressionsR1t_forwarding_rule(tselftforwarding_rule((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt__init__ns   cC`sTttdrtjdSx0|jD]%}t|dr'|jjq'q'WdS(Nt_filters_mutatedt__warningregistry__(thasattrRRzt _tmp_modulesR{tclear(RwRq((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt_clear_registriesxs  tcC`s|rg}nd}|jr|dkrFtjdd|d|nR|jjddd}tjdd|d|d||jj||j|j j ||t j |t j ||fn.|jj ||t j |t j ||f|S(NRRtmessaget.s\.t$Rq(tNoneRtRtfilterwarningsRtreplaceR}taddRt_tmp_suppressionstappendtretcompiletIRu(RwRRRqRt module_regex((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt_filters$     ( %c C`s&|jd|d|d|dtdS(s Add a new suppressing filter or apply it if the state is entered. Parameters ---------- category : class, optional Warning class to filter message : string, optional Regular expression matching the warning message. module : module, optional Module to filter for. Note that the module (and its file) must match exactly and cannot be a submodule. This may make it unreliable for external modules. Notes ----- When added within a context, filters are only added inside the context and will be forgotten when the context is exited. RRRqRN(RR/(RwRRRq((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pytfiltersc C`s"|jd|d|d|dtS(s Append a new recording filter or apply it if the state is entered. All warnings matching will be appended to the ``log`` attribute. Parameters ---------- category : class, optional Warning class to filter message : string, optional Regular expression matching the warning message. module : module, optional Module to filter for. Note that the module (and its file) must match exactly and cannot be a submodule. This may make it unreliable for external modules. Returns ------- log : list A list which will be filled with all matched warnings. Notes ----- When added within a context, filters are only added inside the context and will be forgotten when the context is exited. RRRqR(RR (RwRRRq((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyRsc C`s0|jrtdntj|_tj|_|jt_t|_g|_t |_ t |_ g|_ x|j D]\}}}}}|dk r|2n|dkrtjdd|d|qz|jjddd}tjdd|d|d||j j|qzW|jt_|j|S( Ns%cannot enter suppress_warnings twice.RRRRs\.RRq(Rtt RuntimeErrorRt showwarningt _orig_showtfilterst_filtersR RtsetR}t _forwardedtlogRuRRRRRt _showwarningR(Rwtcattmesst_tmodRR((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt __enter__s0             cG`s;|jt_|jt_|jt|_|`|`dS(N(RRRRRRR/Rt(Rwtexc_info((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt__exit__s     cO`s;|jdd}x|j|jdddD]\}} } } } t||r0| j|jddk r0| dkr| dk rt|||||} |jj | | j | ndS| j j |r!| dk rt|||||} |jj | | j | ndSq0q0W|j dkrp|dkr_|j ||||||n |j|dS|j dkr|j|f}nK|j dkr|j||f}n'|j dkr|j|||f}n||jkrdS|jj||dkr*|j ||||||n |j|dS(Nt use_warnmsgiiRRrRqRs(tpopRRuRt issubclasstmatchRRRRt__file__t startswithRvRt _orig_showmsgRR(RwRRtfilenametlinenoRtkwargsRRRtpatternRtrectmsgt signature((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyRsL0             c`s"tfd}|S(sk Function decorator to apply certain suppressions to a whole function. c`s||SWdQXdS(N((RR(RRw(s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pytnew_func3s(R(RwRR((RRws7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyt__call__.sN(Rt __module__t__doc__RyRtWarningRR/RRRRRRR(((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyRp'sF   4(tcov(R.taveragetdotcC`sm|dk r-|t|kr-tdntj|}|jdkrZtdn|dkr~tj|tj}nEtj|}|jdkrtdntj||tj}t|ddd|}| r|j ddkr|j }n|j ddkr-tjgj ddS|dk rt|d t ddd|}| r}|j ddkr}|j }ntj ||fd d}n|dkr|dkrd}qd}nd} |dk rtj|dt}tj|tj|kstd n|jdkr7td n|j d|j dkr`td nt|dkrtdn|} n|dk r5tj|dt}|jdkrtdn|j d|j dkrtdnt|dkrtdn| dkr(|} q5| |9} nt|d dd| dt\} } | d} | dkr|j d|} nJ|dkr| } n5|dkr| |} n| |t| || } | dkrtjdtddd} n|| dddf8}| dkr*|j } n || j } t|| j}|dtj| 9}|jS(s1 Estimate a covariance matrix, given data and weights. 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`. See the notes for an outline of the algorithm. 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 : bool, optional If `rowvar` is True (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 : bool, optional Default normalization (False) is by ``(N - 1)``, where ``N`` is the number of observations given (unbiased estimate). If `bias` is True, then normalization is by ``N``. These values can be overridden by using the keyword ``ddof`` in numpy versions >= 1.5. ddof : int, optional If not ``None`` the default value implied by `bias` is overridden. Note that ``ddof=1`` will return the unbiased estimate, even if both `fweights` and `aweights` are specified, and ``ddof=0`` will return the simple average. See the notes for the details. The default value is ``None``. .. versionadded:: 1.5 fweights : array_like, int, optional 1-D array of integer freguency weights; the number of times each observation vector should be repeated. .. versionadded:: 1.10 aweights : array_like, optional 1-D array of observation vector weights. These relative weights are typically large for observations considered "important" and smaller for observations considered less "important". If ``ddof=0`` the array of weights can be used to assign probabilities to observation vectors. .. versionadded:: 1.10 Returns ------- out : ndarray The covariance matrix of the variables. See Also -------- corrcoef : Normalized covariance matrix Notes ----- Assume that the observations are in the columns of the observation array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The steps to compute the weighted covariance are as follows:: >>> w = f * a >>> v1 = np.sum(w) >>> v2 = np.sum(w * a) >>> m -= np.sum(m * w, axis=1, keepdims=True) / v1 >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2) Note that when ``a == 1``, the normalization factor ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)`` as it should. 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.stack((x, y), axis=0) >>> 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 sddof must be integerism has more than 2 dimensionssy has more than 2 dimensionsRaRBiiRRbsfweights must be integers'cannot handle multidimensional fweightss,incompatible numbers of samples and fweightssfweights cannot be negatives'cannot handle multidimensional aweightss,incompatible numbers of samples and aweightssaweights cannot be negativetweightstreturneds!Degrees of freedom <= 0 for slicet stacklevelgNg?(RtintR1R+RgRjt result_typetfloat64R.R0tTRiR/RPtfloattalltaroundt TypeErrorRR2RR tsumRtwarntRuntimeWarningRtconjtsqueeze(tmtytrowvartbiastddoftfweightstaweightsRBtXtwtavgtw_sumtfacttX_Ttc((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pyR?sr                      $             ($Rt __future__RRRRRRt functoolsRtnumpyR+tscipy._lib._versionRt __version__ttestingt assert_warnsRRRR7R/R:REt polynomialRoR t numpy.testingRpt ImportErrortobjectRR.RRR(((s7lib/python2.7/site-packages/scipy/_lib/_numpy_compat.pytsD    #    [ Y